Comprehensive Tool Ecosystem Catalog

Last Updated: 2025-11-04 Environment: macOS Darwin 25.1.0 Status: Active (Note: BuildKit CLI has unresolved module dependencies)

1. BuildKit Commands (Agent Framework)

Overview

BuildKit is the primary command automation framework for your ecosystem. Defined in ~/.claude/buildkit-commands.yaml and bootstrapped from $LLM_ROOT/agent-buildkit/.

Package: @bluefly/agent-buildkit v0.1.2 CLI Entry: buildkit (alias to $LLM_ROOT/agent-buildkit/bin/buildkit) Status: Broken (Missing module: ../../core/orchestrator/discovery)

Golden Commands (Primary Interface)

These are the highest-level, most commonly used commands:

buildkit golden test

Comprehensive testing workflow (unit + integration + e2e + security)

buildkit golden test                    # Run all tests
buildkit golden test --type unit        # Unit tests only
buildkit golden test --type integration # Integration tests
buildkit golden test --type e2e         # End-to-end tests
buildkit golden test --coverage         # Generate coverage report
buildkit golden test --watch            # Watch mode

buildkit golden deploy

Complete deployment pipeline

buildkit golden deploy --env dev        # Deploy to dev
buildkit golden deploy --env staging    # Deploy to staging
buildkit golden deploy --env prod       # Deploy to production
buildkit golden deploy --namespace llm-agents  # Custom K8s namespace
buildkit golden deploy --dry-run        # Preview deployment

buildkit golden agent

Agent lifecycle management (OSSA, SubAgents)

buildkit golden agent create            # Create agent from OSSA manifest
buildkit golden agent deploy            # Deploy agent to Kubernetes
buildkit golden agent execute --task "description"  # Execute agent task
buildkit golden agent list              # List all agents
buildkit golden agent delete            # Delete agent
buildkit golden agent status            # Check agent status

buildkit golden review

Comprehensive code review (style, security, performance, architecture)

buildkit golden review src/             # Review directory
buildkit golden review src/file.ts      # Review specific file
buildkit golden review --severity high  # High severity only
buildkit golden review --fix            # Auto-fix issues

buildkit golden sync

Sync everything with GitLab (issues, wiki, roadmap, milestones)

buildkit golden sync                    # Sync everything
buildkit golden sync --create-issues    # Create issues from roadmap
buildkit golden sync --update-roadmap   # Update roadmap
buildkit golden sync --sync-wiki        # Sync docs to GitLab Wiki

buildkit golden audit

Security, compliance, and quality audit

buildkit golden audit                   # Run full audit
buildkit golden audit --report          # Generate audit report
buildkit golden audit --fix             # Auto-fix issues

buildkit golden fix

Auto-fix common issues

buildkit golden fix                     # Auto-fix all
buildkit golden fix --ci                # Fix CI failures
buildkit golden fix --deps              # Fix dependency issues
buildkit golden fix --cleanup           # Clean temporary files

buildkit golden docs

Generate and publish documentation

buildkit golden docs --generate         # Generate documentation
buildkit golden docs --publish          # Publish to GitLab Wiki
buildkit golden docs --openapi          # Generate OpenAPI docs

buildkit golden monitor

Set up observability stack

buildkit golden monitor --setup         # Set up monitoring
buildkit golden monitor --dashboard     # Open dashboard

buildkit golden workflow

Feature/bug/release workflows

buildkit golden workflow feature "Feature name"   # Feature branch
buildkit golden workflow bug "Bug description"    # Bug fix
buildkit golden workflow release "v1.0.0"        # Release

buildkit golden optimize

NEW: Check if agents should be used for task

buildkit golden optimize                # Analyze token/complexity
buildkit golden optimize --suggest-agents  # Suggest which agents

buildkit golden taste

NEW: Validate code against design principles

buildkit golden taste [path]            # Check design taste
buildkit golden taste --report          # Detailed report

Command Groups

Agent Management

buildkit agent create --manifest agent.yaml
buildkit agent deploy --manifest agent.yaml --namespace llm-agents
buildkit agent execute --name my-agent --task "task description"
buildkit agent list --namespace llm-agents
buildkit agent delete --name my-agent

SubAgent Orchestration

buildkit subagent create --name orchestrator --type testing
buildkit subagent execute --manifest manifest.yaml --task "task"
buildkit subagent list --manifest manifest.yaml
buildkit subagent validate --manifest manifest.yaml

GitLab Operations

buildkit gitlab roadmap-sync --create-issues
buildkit gitlab wiki create --slug "page-name" --file file.md
buildkit gitlab issues list
buildkit gitlab issues create --title "Issue"
buildkit gitlab milestones list
buildkit gitlab labels list

Testing

buildkit test --type unit --coverage
buildkit security --scan
buildkit security --report

Infrastructure

buildkit infrastructure deploy --namespace default
buildkit k8s list pods
buildkit k8s describe pod <pod-name>
buildkit monitor --setup
buildkit monitor --dashboard

Documentation

buildkit docs generate
buildkit docs sync --all
buildkit docs-automation --scan
buildkit docs-automation --sync

OSSA (Agent Standard)

buildkit ossa validate --manifest manifest.json
buildkit ossa migrate --from v0.1 --to v1.0
ossa init <agent-name> --type worker
ossa validate .agents/<agent-name>/manifest.json
ossa migrate .agents/<old>/ --output .agents/<new>/

Ecosystem Management

buildkit ecosystem sync --all
buildkit ecosystem health --report

Observability (Phoenix, Prometheus, Grafana)

buildkit phoenix --setup
buildkit phoenix --dashboard
buildkit telemetry-aggregate --export
buildkit telemetry-aggregate --analyze

MCP (Model Context Protocol)

buildkit mcp-registry --list
buildkit mcp-registry --add <server-name>
buildkit mcp-servers --start
buildkit mcp-servers --stop
buildkit mcp-tools --list
buildkit mcp-tools --describe <tool-name>

NPM Scripts in BuildKit Package

Located in $LLM_ROOT/agent-buildkit/package.json:

Build & Development

npm run build                    # Build TypeScript
npm run build:cli              # Build CLI
npm run dev                    # Watch mode
npm run typecheck              # Type check
npm run lint                   # ESLint
npm run lint:fix              # ESLint with fixes
npm run format                # Prettier format
npm run format:check          # Check formatting

Testing

npm run test                   # Jest unit tests
npm run test:unit             # Unit tests
npm run test:integration      # Integration tests
npm run test:all              # All tests
npm run test:watch            # Watch mode
npm run test:coverage         # Coverage report

Type Generation

npm run generate              # All types
npm run generate:types        # OpenAPI types
npm run generate:token-types  # Token management types
npm run generate:wiki-types   # Wiki types

Token Management

npm run tokens:server         # Token server
npm run tokens:cli            # Token CLI
npm run tokens:sync           # Sync tokens
npm run tokens:sync:dry       # Dry run sync

Vault Integration

npm run vault:dev             # Dev vault server
npm run vault:setup           # Setup vault
npm run vault:import          # Import tokens to vault
npm run vault:import:dry      # Dry run import
npm run vault:codemod         # Code migration
npm run vault:codemod:dry     # Dry run codemod
npm run vault:k8s:*           # K8s vault operations

Proxy & Services

npm run proxy:start           # Start Vortex proxy
npm run proxy:dev             # Dev proxy with watch
npm run proxy:setup           # Setup proxy
npm run services:start        # Start services (production)
npm run services:start:dev    # Start services (dev)
npm run services:stop         # Stop services
npm run services:restart      # Restart services
npm run services:status       # Service status
npm run services:health       # Health check
npm run services:discover     # Discover services
npm run services:cleanup      # Cleanup services

Agent & OSSA Workflows

npm run swarm:ossa            # Spawn OSSA standard
npm run swarm:ossa:dry-run    # Dry run OSSA swarm
npm run ossa:register         # Register with learning
npm run ossa:find-work        # Find available work
npm run ossa:workload         # Check workload

GitLab & Knowledge Graph

npm run gitlab:kg-build       # Build knowledge graph
npm run gitlab:kg-sync        # Sync knowledge graph
npm run gitlab:kg-query       # Query knowledge graph
npm run gitlab:kg-related     # Find related issues
npm run gitlab:kg-assign      # Assign opportunities
npm run gitlab:kg-export      # Export knowledge graph
npm run gitlab:milestones     # Manage milestones
npm run gitlab:labels         # Manage labels
npm run gitlab:roadmap        # Fetch roadmap

Documentation Automation

npm run docs:scan             # Scan for action items
npm run docs:to-roadmap       # Convert docs to roadmap
npm run docs:to-gitlab        # Sync to GitLab
npm run docs:validate         # Validate structure
npm run docs:sync             # Sync docs
npm run update-roadmap        # Update roadmap
npm run extract-action-items  # Extract from docs
npm run enrich-issues         # Enrich GitLab issues
npm run complete-automation   # Full automation cycle

Daemon Operations

npm run daemon:start          # Start daemon
npm run daemon:dev            # Dev daemon
npm run daemon:docker         # Docker daemon
npm run daemon:k8s:deploy     # Deploy to K8s
npm run daemon:k8s:status     # K8s status
npm run daemon:k8s:logs       # K8s logs

Docker & Container

npm run worker:build          # Build worker image
npm run worker:test           # Test worker
npm run worker:up             # Start worker
npm run worker:down           # Stop worker
npm run container:build       # Build all containers
npm run container:up          # Start orchestrator
npm run container:down        # Stop orchestrator
npm run container:logs        # View logs

Infrastructure

npm run k8s:migrate           # K8s migration
npm run swarm:coordinate      # Coordinate swarm
npm run platform:launch       # Launch platform
npm run orbstack:route        # Route agent
npm run orbstack:scale        # Auto-scale
npm run orbstack:monitor      # Monitor OrbStack

LangFlow Integration

npm run langflow:install      # Install LangFlow
npm run langflow:dev          # Dev server
npm run langflow:export       # Export flows
npm run langflow:import       # Import flows
npm run langflow:execute      # Execute flow
npm run langflow:list         # List flows
npm run langflow:wizard       # Setup wizard

MCP Server Management

npm run mcp-servers           # List MCP servers
npm run mcp-servers:start     # Start all servers
npm run mcp-servers:stop      # Stop all servers
npm run mcp-servers:status    # Server status
npm run mcp-servers:restart   # Restart servers

Thinking & Sequential Reasoning

npm run thinking:setup        # Setup thinking module
npm run thinking:start        # Start thinking service
npm run thinking:spawn-agent  # Spawn thinking agent
npm run thinking:configure-ide # IDE configuration

2. CLI Tools (System-Level)

Git (Version Control)

git version
git status
git add .
git commit -m "message"
git push
git pull
git branch
git worktree add <path> <branch>
git worktree remove <path>

Usage: Primary version control for all repositories Location: /usr/bin/git

GitLab CLI (glab)

Version: 1.55.0 Location: /opt/homebrew/bin/glab

# Issues
glab issue create --title "Feature: ..."
glab issue list
glab issue view <issue-id>
glab issue close <issue-id>

# Merge Requests
glab mr create --source-branch feature --target-branch main
glab mr view
glab mr merge <mr-id>
glab mr list

# Pipelines
glab pipeline list
glab pipeline status
glab pipeline view <pipeline-id>

# Branches
glab repo clone <project>
glab repo fork <project>

# Releases
glab release list
glab release create --tag v1.0.0

Usage: GitLab operations without BuildKit (native API calls) Documentation: glab --help

npm & pnpm

npm Version: 10.9.3 Node Version: v22.19.0 pnpm Location: ~/.volta/bin/pnpm

# Package management
npm install
npm update
npm audit
npm audit fix
npm list

# Scripts
npm run <script-name>
npm run dev
npm run build
npm run test

# Dependencies
npm ci              # Clean install
npm ls --depth=0    # List top-level deps
npm outdated        # Check outdated packages

Usage: Node.js ecosystem package management

Composer (PHP)

Location: /usr/local/bin/composer

# Dependency management
composer install
composer update
composer require <package>
composer remove <package>
composer audit

# Scripts
composer run-script <script>
composer phpcs
composer phpstan

# Info
composer show
composer outdated

Usage: PHP/Drupal dependency management

Drush (Drupal CLI)

Location: ~/.composer/vendor/bin/drush

# Cache & Config
drush cache:clear (cr)
drush config:export (cex)
drush config:import (cim)

# Database
drush database:update (updb)
drush sql:dump

# Module/Theme
drush module:install
drush module:uninstall
drush theme:install
drush theme:uninstall

# Status
drush status
drush core:requirement

Usage: Drupal 10+ site operations Integration: Called via buildkit drupal commands

DDEV (Local Development)

Location: /usr/local/bin/ddev

# Project setup
ddev start
ddev stop
ddev restart
ddev delete

# SSH
ddev ssh
ddev exec <command>

# Logs
ddev logs
ddev logs -s web

# Service management
ddev version
ddev debug

Usage: Local PHP/Drupal development environment

Docker

Location: /usr/local/bin/docker

# Images
docker build -f Dockerfile -t image:tag .
docker images
docker pull <image>

# Containers
docker run -d --name container image:tag
docker ps
docker logs <container>
docker stop <container>

# Compose
docker compose up -d
docker compose down
docker compose logs -f
docker compose ps

Usage: Container management and orchestration

kubectl (Kubernetes)

Location: /usr/local/bin/kubectl

# Resources
kubectl get pods/services/deployments
kubectl apply -f manifest.yaml
kubectl delete -f manifest.yaml

# Info
kubectl describe pod <pod-name>
kubectl logs <pod-name>
kubectl exec -it <pod-name> -- bash

# Namespaces
kubectl get ns
kubectl create ns <namespace>
kubectl config set-context --current --namespace=<namespace>

# Deployments
kubectl rollout restart deployment <name>
kubectl scale deployment <name> --replicas=3

Usage: Kubernetes cluster operations

Helm (K8s Package Manager)

Location: /opt/homebrew/bin/helm

# Charts
helm list
helm repo list
helm repo add <name> <url>
helm search <chart>

# Deployments
helm install <release> <chart>
helm upgrade <release> <chart>
helm uninstall <release>

# Status
helm status <release>
helm history <release>

Usage: Kubernetes package management

3. MCP (Model Context Protocol) Servers

MCP servers provide specialized capabilities to Claude Code:

Available MCP Servers

mcpmemory (Knowledge Graph)

Graph-based knowledge management

# Create entities
mcp__memory__create_entities
  - name: string
  - entityType: string
  - observations: string[]

# Create relations
mcp__memory__create_relations
  - from: string (entity name)
  - to: string (entity name)
  - relationType: string

# Add observations
mcp__memory__add_observations
  - entityName: string
  - contents: string[]

# Search nodes
mcp__memory__search_nodes
  - query: string (pattern match)

# Read full graph
mcp__memory__read_graph

# Open specific nodes
mcp__memory__open_nodes
  - names: string[]

# Delete entities
mcp__memory__delete_entities
  - entityNames: string[]

# Delete observations
mcp__memory__delete_observations
  - entityName: string
  - observations: string[]

# Delete relations
mcp__memory__delete_relations
  - from: string
  - to: string
  - relationType: string

mcpfilesystem (File Operations)

File system access and manipulation

# Read files
mcp__filesystem__read_text_file(path, head?, tail?)
mcp__filesystem__read_media_file(path)  # Images, audio
mcp__filesystem__read_multiple_files(paths[])

# Write files
mcp__filesystem__write_file(path, content)
mcp__filesystem__edit_file(path, edits[], dryRun?)

# Directory operations
mcp__filesystem__list_directory(path)
mcp__filesystem__list_directory_with_sizes(path, sortBy?)
mcp__filesystem__directory_tree(path)
mcp__filesystem__create_directory(path)

# Search & Info
mcp__filesystem__search_files(path, pattern, excludePatterns?)
mcp__filesystem__get_file_info(path)
mcp__filesystem__move_file(source, destination)

# Utilities
mcp__filesystem__list_allowed_directories

mcpgitlab (GitLab Integration)

GitLab project and repository operations

# Repository management
mcp__gitlab__search_repositories(search, page?, per_page?)
mcp__gitlab__create_repository(name, description?, visibility?, initialize_with_readme?)
mcp__gitlab__fork_repository(project_id, namespace?)
mcp__gitlab__create_branch(project_id, branch, ref?)

# File operations
mcp__gitlab__get_file_contents(project_id, file_path, ref?)
mcp__gitlab__create_or_update_file(project_id, file_path, content, commit_message, branch)
mcp__gitlab__push_files(project_id, branch, files[], commit_message)

# Issue management
mcp__gitlab__create_issue(project_id, title, description?, assignee_ids?, labels?, milestone_id?)

# Merge requests
mcp__gitlab__create_merge_request(project_id, title, source_branch, target_branch, description?, draft?, allow_collaboration?)

mcppostgres (Database)

PostgreSQL query execution

mcp__postgres__query(sql)  # Read-only SQL queries

mcpredis (Cache/Session Storage)

Redis key-value operations

mcp__redis__set(key, value, expireSeconds?)
mcp__redis__get(key)
mcp__redis__delete(key | key[])
mcp__redis__list(pattern)

mcpagent-mesh (Agent Coordination)

Multi-agent communication and orchestration

# Discovery
mcp__agent-mesh__mesh_agents_discover(namespace?, status?)

# Routing
mcp__agent-mesh__mesh_routing_status(detailed?)

# Health
mcp__agent-mesh__mesh_health_check(includeMetrics?)

# Communication
mcp__agent-mesh__mesh_coordinate_agents(sourceAgent, targetAgent, message?)

mcpsequential-thinking (Thinking/Planning)

Structured problem-solving and planning

mcp__sequential-thinking__sequentialthinking(
  thought: string,
  nextThoughtNeeded: boolean,
  thoughtNumber: number,
  totalThoughts: number,
  isRevision?: boolean,
  revisesThought?: number,
  branchFromThought?: number,
  branchId?: string,
  needsMoreThoughts?: boolean
)

4. Git Hooks (Automation)

Hook Framework: Lefthook

Configuration Files:

$LLM_ROOT/technical-guide/lefthook.yml (Project)
~/.cursor/lefthook-template.yml (Template)

Hook Types & Rules

pre-commit Hooks

Run before code is committed:

block-root-md: Prevents markdown files in root (except README.md)
- Enforces GitLab Wiki-first documentation
- Command: git diff --cached --name-only --diff-filter=A
block-sh-scripts: Prevents shell scripts (enforces GitLab CI instead)
- Files: *.sh
format: TypeScript/JavaScript formatting
- Command: npm run format (if package.json exists)
lint: ESLint validation
- Command: npm run lint
typecheck: TypeScript type checking
- Command: npm run typecheck
phpcs: PHP Code Sniffer (Drupal)
- Command: composer phpcs (if composer.json exists)
phpstan: PHP static analysis (Drupal)
- Command: composer phpstan

commit-msg Hooks

Run on commit message:

claude-protection: Blocks AI attribution
- Forbidden: "Generated with Claude", "Co-Authored-By: Claude", , "claude.ai"
- Enforces human-authored commit messages
require-issue-ref: Recommends GitLab Issue references
- Warning for feature/bug/hotfix/chore branches
- Format: feat: description (fixes #123)

pre-push Hooks

Run before pushing:

test: Run test suite
- Commands: npm test or composer test
security-audit: npm audit (warning only)
- Does not block push

Using Lefthook

# Install lefthook (if not installed)
brew install lefthook

# Initialize in repository
lefthook install

# Run hooks manually
lefthook run pre-commit
lefthook run commit-msg --stdin "commit message"
lefthook run pre-push

# Bypass hooks (NOT RECOMMENDED)
git commit --no-verify  #  NEVER DO THIS (violates policy)

5. Automation Scripts & Utilities

Git Utilities

Located in BuildKit package:

npm run git:cleanup           # Clean merged branches
npm run git:cleanup:dry       # Preview cleanup
npm run git:cleanup:all       # Clean all branches

# Usage:
# Automatically removes local branches that have been merged
# Useful for maintaining clean branch list

Documentation Automation

npm run extract-action-items  # Extract TODOs from docs
npm run update-roadmap        # Update roadmap
npm run sync-to-gitlab        # Sync to GitLab

# Full cycle:
npm run complete-automation   # All of the above

Python Scripts (Ecosystem Automation)

Located in $LLM_ROOT/agent-buildkit/scripts/:

python scripts/scan-docs-action-items.py
python scripts/validate-docs-structure.py
python scripts/sync-docs.py --to-wiki --to-pages
python scripts/enrich-and-track.py

Vault Integration (Secrets Management)

npm run vault:setup           # Initial setup
npm run vault:import          # Import tokens
npm run vault:codemod         # Code migration
npm run vault:k8s:setup       # K8s vault setup
npm run vault:k8s:unseal      # Unseal vault

Ecosystem Health Checks

npm run services:health       # Service health
npm run ecosystem:health      # Ecosystem status
npm run services:discover     # Auto-discover services
npm run cleanup:scan          # Scan for issues
npm run cleanup:fix           # Auto-fix issues

6. Project Structure & Source Locations

Editable Locations (Custom Code)

Drupal Custom Development:

$LLM_ROOT/all_drupal_custom/
 modules/*                # Custom modules
 recipes/*                # Drupal recipes
 themes/*                 # Custom themes

BuildKit Source:

$LLM_ROOT/agent-buildkit/
 src/
 dist/
 package.json
 tsconfig.json
 jest.config.js

Common NPM Packages:

$LLM_ROOT/common_npm/

OSSA Agents:

$LLM_ROOT/OSSA/
$LLM_ROOT/.agents/

Protected Locations (Composer-Managed)

$LLM_ROOT/llm-platform/web/*   DO NOT EDIT

These are managed by Composer and will be overwritten.

7. Secrets & Credentials

Token Locations

All tokens stored in home directory (automatically loaded):

~/.tokens/gitlab         # GitLab API token
~/.tokens/openai         # OpenAI API key
~/.tokens/anthropic      # Anthropic API key

Note: NEVER ask for tokens - they're already configured.

Vault Integration

Secrets can be managed in HashiCorp Vault:

npm run vault:setup           # Initialize vault
npm run vault:k8s:deploy      # Deploy to K8s
npm run vault:import          # Import existing tokens

8. Critical Rules & Restrictions

Absolute Prohibitions

NEVER use /bin/rm, /usr/bin/rm, or sudo rm
NEVER bypass git hooks (--no-verify, HUSKY=0)
NEVER edit Composer paths: $LLM_ROOT/llm-platform/web/*
NEVER create shell scripts (use BuildKit, GitLab CI, or NPM scripts)
NEVER create local .md files (use GitLab Wiki only)
NEVER commit directly to main/master/development
NEVER create MRs via CLI (use GitLab issue "Create merge request" button)

Mandatory Workflows

ALWAYS use GitLab Wiki for ALL documentation
ALWAYS use GitLab Issues for ALL tasks/TODOs
ALWAYS create issue BEFORE starting work
ALWAYS use git worktrees (never switch branches)
ALWAYS create MRs via GitLab issue button
ALWAYS check BuildKit first for tasks
ALWAYS spawn agents for tasks > 500 tokens or 3+ files

9. Decision Trees & Selection Guide

Should I Use Agents?

# Quick check
buildkit golden optimize

# Manual decision:
if [tokens > 500] || [files > 3] || [repetitive]; then
    buildkit agents search --description "task"
    # Spawn agents for parallel work
else
    # Direct implementation is acceptable
fi

Command Selection

Task Type              Primary Command

Testing               buildkit golden test
Deployment            buildkit golden deploy
Code Review           buildkit golden review
Agents                buildkit golden agent
GitLab Sync           buildkit golden sync
Security Audit        buildkit golden audit
Documentation         buildkit golden docs
Auto-Fix              buildkit golden fix
Workflows             buildkit golden workflow
Monitoring            buildkit golden monitor

Tool Selection by Task

Task                  Tool/Command

Version Control       git / glab
Package Mgmt          npm / composer
PHP/Drupal Dev        composer / drush
Local Dev Env         ddev
Database Queries      mcp__postgres__
File Operations       mcp__filesystem__
Agent Coordination    mcp__agent-mesh__
Problem Solving       mcp__sequential-thinking__
Git Hooks             lefthook
Testing               npm run test
API Specs             OpenAPI standards

10. Common Workflows

Complete Testing Workflow

buildkit golden test                    # Run all tests
buildkit golden test --coverage         # Generate coverage
buildkit golden audit                   # Security scan
buildkit golden review src/             # Code review

Feature Development Workflow

# 1. Create GitLab issue
glab issue create --title "Feature: Add X"

# 2. Create MR from issue page (GitLab)

# 3. Set up worktree
git fetch origin
git worktree add ../llm-platform-worktrees/123-feature ../123-feature

# 4. Make changes & commit
cd ../llm-platform-worktrees/123-feature
git add .
git commit -m "feat: implement X (fixes #123)"
git push

# 5. MR already linked - just push!

# 6. Clean up after merge
git worktree remove ../llm-platform-worktrees/123-feature

Deployment Workflow

buildkit golden test                    # Verify all tests pass
buildkit golden deploy --env staging    # Deploy to staging
buildkit golden deploy --env prod       # Deploy to production
buildkit golden monitor --dashboard     # Monitor

Agent Creation & Deployment

# 1. Create OSSA manifest
cat > agent.yaml << EOF
name: my-agent
type: worker
version: "0.1.0"
EOF

# 2. Validate manifest
ossa validate agent.yaml

# 3. Create and deploy
buildkit golden agent create --manifest agent.yaml
buildkit golden agent deploy --manifest agent.yaml
buildkit golden agent execute --name my-agent --task "test"

Documentation & Knowledge Graph Sync

npm run docs:scan                       # Find action items
npm run docs:to-gitlab                  # Sync to GitLab
buildkit golden sync --create-issues    # Create issues
buildkit gitlab:kg-build                # Build knowledge graph

Summary Table: Quick Reference

Category	Tool	Status	Usage
CLI Framework	buildkit	Broken*	Command orchestration
Git	git / glab	Active	Version control
Node.js	npm / pnpm	Active	Package management
PHP	composer	Active	Drupal dependencies
Drupal	drush / ddev	Active	Site operations
Container	docker / kubectl	Active	Container orchestration
Automation	lefthook	Active	Git hooks
Knowledge	mcp__memory__	Active	Knowledge graph
Files	mcp__filesystem__	Active	File operations
GitLab	mcp__gitlab__	Active	Project management
Database	mcp__postgres__	Active	Queries
Cache	mcp__redis__	Active	Key-value store
Agents	mcp__agent-mesh__	Active	Agent coordination
Thinking	mcp__sequential-thinking__	Active	Structured problem-solving

Note: BuildKit has unresolved module dependency (orchestrator/discovery). This may require rebuilding or checking the agent-buildkit source.

Maintenance & Support

Documentation: https://gitlab.com/blueflyio/agent-platform/documentation/-/wikis/home Issues: https://gitlab.com/blueflyio/agent-platform/documentation/-/issues BuildKit Repo: https://gitlab.com/blueflyio/agent-platform/agent-buildkit OSSA Spec: https://gitlab.com/blueflyio/agent-platform/ossa Command Registry: ~/.claude/buildkit-commands.yaml

Generated: 2025-11-04 by Claude Code Format: Markdown (View in GitLab Wiki or editor)

Comprehensive Tool Ecosystem Catalog

Comprehensive Tool Ecosystem Catalog

1. BuildKit Commands (Agent Framework)

Overview

Golden Commands (Primary Interface)

buildkit golden test

buildkit golden deploy

buildkit golden agent

buildkit golden review

buildkit golden sync

buildkit golden audit

buildkit golden fix

buildkit golden docs

buildkit golden monitor

buildkit golden workflow

buildkit golden optimize

buildkit golden taste

Command Groups

Agent Management

SubAgent Orchestration

GitLab Operations

Testing

Infrastructure

Documentation

OSSA (Agent Standard)

Ecosystem Management

Observability (Phoenix, Prometheus, Grafana)

MCP (Model Context Protocol)

NPM Scripts in BuildKit Package

Build & Development

Testing

Type Generation

Token Management

Vault Integration

Proxy & Services

Agent & OSSA Workflows

GitLab & Knowledge Graph

Documentation Automation

Daemon Operations

Docker & Container

Infrastructure

LangFlow Integration

MCP Server Management

Thinking & Sequential Reasoning

2. CLI Tools (System-Level)

Git (Version Control)

GitLab CLI (glab)

npm & pnpm

Composer (PHP)

Drush (Drupal CLI)

DDEV (Local Development)

Docker

kubectl (Kubernetes)

Helm (K8s Package Manager)

3. MCP (Model Context Protocol) Servers

Available MCP Servers

mcp__memory__ (Knowledge Graph)

mcp__filesystem__ (File Operations)

mcp__gitlab__ (GitLab Integration)

mcp__postgres__ (Database)

mcp__redis__ (Cache/Session Storage)

mcp__agent-mesh__ (Agent Coordination)

mcp__sequential-thinking__ (Thinking/Planning)

4. Git Hooks (Automation)

Hook Framework: Lefthook

Hook Types & Rules

pre-commit Hooks

commit-msg Hooks

pre-push Hooks

Using Lefthook

5. Automation Scripts & Utilities

Git Utilities

Documentation Automation

Python Scripts (Ecosystem Automation)

Vault Integration (Secrets Management)

Ecosystem Health Checks

6. Project Structure & Source Locations

Editable Locations (Custom Code)

Protected Locations (Composer-Managed)

7. Secrets & Credentials

mcpmemory (Knowledge Graph)

mcpfilesystem (File Operations)

mcpgitlab (GitLab Integration)

mcppostgres (Database)

mcpredis (Cache/Session Storage)

mcpagent-mesh (Agent Coordination)

mcpsequential-thinking (Thinking/Planning)