@claude-flow/cli 3.0.0-alpha.33 → 3.0.0-alpha.35

package/.claude/commands/workflows/development.md

@@ -0,0 +1,78 @@
+# Development Workflow Coordination
+
+## Purpose
+Structure Claude Code's approach to complex development tasks for maximum efficiency.
+
+## Step-by-Step Coordination
+
+### 1. Initialize Development Framework
+```
+Tool: mcp__claude-flow__swarm_init
+Parameters: {"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}
+```
+Creates hierarchical structure for organized, top-down development.
+
+### 2. Define Development Perspectives
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "architect",
+  "name": "System Design",
+  "capabilities": ["api-design", "database-schema"]
+}
+```
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "coder",
+  "name": "Implementation Focus",
+  "capabilities": ["nodejs", "typescript", "express"]
+}
+```
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "tester",
+  "name": "Quality Assurance",
+  "capabilities": ["unit-testing", "integration-testing"]
+}
+```
+Sets up architectural and implementation thinking patterns.
+
+### 3. Coordinate Implementation
+```
+Tool: mcp__claude-flow__task_orchestrate
+Parameters: {
+  "task": "Build REST API with authentication",
+  "strategy": "parallel",
+  "priority": "high",
+  "dependencies": ["database setup", "auth system"]
+}
+```
+
+### 4. Monitor Progress
+```
+Tool: mcp__claude-flow__task_status
+Parameters: {"taskId": "api-build-task-123"}
+```
+
+## What Claude Code Actually Does
+1. Uses **Write** tool to create new files
+2. Uses **Edit/MultiEdit** tools for code modifications
+3. Uses **Bash** tool for testing and building
+4. Uses **TodoWrite** tool for task tracking
+5. Follows coordination patterns for systematic implementation
+
+Remember: All code is written by Claude Code using its native tools!
+
+## CLI Usage
+```bash
+# Start development workflow via CLI
+npx claude-flow workflow dev "REST API with auth"
+
+# Create custom workflow
+npx claude-flow workflow create --name "api-dev" --steps "design,implement,test,deploy"
+
+# Execute saved workflow
+npx claude-flow workflow execute api-dev
+```

package/.claude/commands/workflows/research.md

@@ -0,0 +1,63 @@
+# Research Workflow Coordination
+
+## Purpose
+Coordinate Claude Code's research activities for comprehensive, systematic exploration.
+
+## Step-by-Step Coordination
+
+### 1. Initialize Research Framework
+```
+Tool: mcp__claude-flow__swarm_init
+Parameters: {"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}
+```
+Creates a mesh topology for comprehensive exploration from multiple angles.
+
+### 2. Define Research Perspectives
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {"type": "researcher", "name": "Literature Review"}
+```
+```
+Tool: mcp__claude-flow__agent_spawn  
+Parameters: {"type": "analyst", "name": "Data Analysis"}
+```
+Sets up different analytical approaches for Claude Code to use.
+
+### 3. Execute Coordinated Research
+```
+Tool: mcp__claude-flow__task_orchestrate
+Parameters: {
+  "task": "Research modern web frameworks performance",
+  "strategy": "adaptive",
+  "priority": "medium"
+}
+```
+
+### 4. Store Research Findings
+```
+Tool: mcp__claude-flow__memory_usage
+Parameters: {
+  "action": "store",
+  "key": "research_findings",
+  "value": "framework performance analysis results",
+  "namespace": "research"
+}
+```
+
+## What Claude Code Actually Does
+1. Uses **WebSearch** tool for finding resources
+2. Uses **Read** tool for analyzing documentation
+3. Uses **Task** tool for parallel exploration
+4. Synthesizes findings using coordination patterns
+5. Stores insights in memory for future reference
+
+Remember: The swarm coordinates HOW Claude Code researches, not WHAT it finds.
+
+## CLI Usage
+```bash
+# Start research workflow via CLI
+npx claude-flow workflow research "modern web frameworks"
+
+# Export research workflow
+npx claude-flow workflow export research --format json
+```

package/.claude/commands/workflows/workflow-create.md

@@ -0,0 +1,25 @@
+# workflow-create
+
+Create reusable workflow templates.
+
+## Usage
+```bash
+npx claude-flow workflow create [options]
+```
+
+## Options
+- `--name <name>` - Workflow name
+- `--from-history` - Create from history
+- `--interactive` - Interactive creation
+
+## Examples
+```bash
+# Create workflow
+npx claude-flow workflow create --name "deploy-api"
+
+# From history
+npx claude-flow workflow create --name "test-suite" --from-history
+
+# Interactive mode
+npx claude-flow workflow create --interactive
+```

package/.claude/commands/workflows/workflow-execute.md

@@ -0,0 +1,25 @@
+# workflow-execute
+
+Execute saved workflows.
+
+## Usage
+```bash
+npx claude-flow workflow execute [options]
+```
+
+## Options
+- `--name <name>` - Workflow name
+- `--params <json>` - Workflow parameters
+- `--dry-run` - Preview execution
+
+## Examples
+```bash
+# Execute workflow
+npx claude-flow workflow execute --name "deploy-api"
+
+# With parameters
+npx claude-flow workflow execute --name "test-suite" --params '{"env": "staging"}'
+
+# Dry run
+npx claude-flow workflow execute --name "deploy-api" --dry-run
+```

package/.claude/commands/workflows/workflow-export.md

@@ -0,0 +1,25 @@
+# workflow-export
+
+Export workflows for sharing.
+
+## Usage
+```bash
+npx claude-flow workflow export [options]
+```
+
+## Options
+- `--name <name>` - Workflow to export
+- `--format <type>` - Export format
+- `--include-history` - Include execution history
+
+## Examples
+```bash
+# Export workflow
+npx claude-flow workflow export --name "deploy-api"
+
+# As YAML
+npx claude-flow workflow export --name "test-suite" --format yaml
+
+# With history
+npx claude-flow workflow export --name "deploy-api" --include-history
+```

package/.claude/helpers/memory.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Claude Flow Memory Helper
+ * Simple key-value memory for cross-session context
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const MEMORY_DIR = path.join(process.cwd(), '.claude-flow', 'data');
+const MEMORY_FILE = path.join(MEMORY_DIR, 'memory.json');
+
+function loadMemory() {
+  try {
+    if (fs.existsSync(MEMORY_FILE)) {
+      return JSON.parse(fs.readFileSync(MEMORY_FILE, 'utf-8'));
+    }
+  } catch (e) {
+    // Ignore
+  }
+  return {};
+}
+
+function saveMemory(memory) {
+  fs.mkdirSync(MEMORY_DIR, { recursive: true });
+  fs.writeFileSync(MEMORY_FILE, JSON.stringify(memory, null, 2));
+}
+
+const commands = {
+  get: (key) => {
+    const memory = loadMemory();
+    const value = key ? memory[key] : memory;
+    console.log(JSON.stringify(value, null, 2));
+    return value;
+  },
+
+  set: (key, value) => {
+    if (!key) {
+      console.error('Key required');
+      return;
+    }
+    const memory = loadMemory();
+    memory[key] = value;
+    memory._updated = new Date().toISOString();
+    saveMemory(memory);
+    console.log(`Set: ${key}`);
+  },
+
+  delete: (key) => {
+    if (!key) {
+      console.error('Key required');
+      return;
+    }
+    const memory = loadMemory();
+    delete memory[key];
+    saveMemory(memory);
+    console.log(`Deleted: ${key}`);
+  },
+
+  clear: () => {
+    saveMemory({});
+    console.log('Memory cleared');
+  },
+
+  keys: () => {
+    const memory = loadMemory();
+    const keys = Object.keys(memory).filter(k => !k.startsWith('_'));
+    console.log(keys.join('\n'));
+    return keys;
+  },
+};
+
+// CLI
+const [,, command, key, ...valueParts] = process.argv;
+const value = valueParts.join(' ');
+
+if (command && commands[command]) {
+  commands[command](key, value);
+} else {
+  console.log('Usage: memory.js <get|set|delete|clear|keys> [key] [value]');
+}
+
+module.exports = commands;

package/.claude/helpers/post-commit

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Claude Flow Post-Commit Hook
+# Records commit metrics and trains patterns
+
+COMMIT_HASH=$(git rev-parse HEAD)
+COMMIT_MSG=$(git log -1 --pretty=%B)
+
+echo "📊 Recording commit metrics..."
+
+# Notify claude-flow of commit
+npx @claude-flow/cli hooks notify \
+  --message "Commit: $COMMIT_MSG" \
+  --level info \
+  --metadata '{"hash": "'$COMMIT_HASH'"}' 2>/dev/null || true
+
+echo "✅ Commit recorded"

package/.claude/helpers/pre-commit

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Claude Flow Pre-Commit Hook
+# Validates code quality before commit
+
+set -e
+
+echo "🔍 Running Claude Flow pre-commit checks..."
+
+# Get staged files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)
+
+# Run validation for each staged file
+for FILE in $STAGED_FILES; do
+  if [[ "$FILE" =~ \.(ts|js|tsx|jsx)$ ]]; then
+    echo "  Validating: $FILE"
+    npx @claude-flow/cli hooks pre-edit --file "$FILE" --validate-syntax 2>/dev/null || true
+  fi
+done
+
+# Run tests if available
+if [ -f "package.json" ] && grep -q '"test"' package.json; then
+  echo "🧪 Running tests..."
+  npm test --if-present 2>/dev/null || echo "  Tests skipped or failed"
+fi
+
+echo "✅ Pre-commit checks complete"

package/.claude/helpers/router.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Claude Flow Agent Router
+ * Routes tasks to optimal agents based on learned patterns
+ */
+
+const AGENT_CAPABILITIES = {
+  coder: ['code-generation', 'refactoring', 'debugging', 'implementation'],
+  tester: ['unit-testing', 'integration-testing', 'coverage', 'test-generation'],
+  reviewer: ['code-review', 'security-audit', 'quality-check', 'best-practices'],
+  researcher: ['web-search', 'documentation', 'analysis', 'summarization'],
+  architect: ['system-design', 'architecture', 'patterns', 'scalability'],
+  'backend-dev': ['api', 'database', 'server', 'authentication'],
+  'frontend-dev': ['ui', 'react', 'css', 'components'],
+  devops: ['ci-cd', 'docker', 'deployment', 'infrastructure'],
+};
+
+const TASK_PATTERNS = {
+  // Code patterns
+  'implement|create|build|add|write code': 'coder',
+  'test|spec|coverage|unit test|integration': 'tester',
+  'review|audit|check|validate|security': 'reviewer',
+  'research|find|search|documentation|explore': 'researcher',
+  'design|architect|structure|plan': 'architect',
+
+  // Domain patterns
+  'api|endpoint|server|backend|database': 'backend-dev',
+  'ui|frontend|component|react|css|style': 'frontend-dev',
+  'deploy|docker|ci|cd|pipeline|infrastructure': 'devops',
+};
+
+function routeTask(task) {
+  const taskLower = task.toLowerCase();
+
+  // Check patterns
+  for (const [pattern, agent] of Object.entries(TASK_PATTERNS)) {
+    const regex = new RegExp(pattern, 'i');
+    if (regex.test(taskLower)) {
+      return {
+        agent,
+        confidence: 0.8,
+        reason: `Matched pattern: ${pattern}`,
+      };
+    }
+  }
+
+  // Default to coder for unknown tasks
+  return {
+    agent: 'coder',
+    confidence: 0.5,
+    reason: 'Default routing - no specific pattern matched',
+  };
+}
+
+// CLI
+const task = process.argv.slice(2).join(' ');
+
+if (task) {
+  const result = routeTask(task);
+  console.log(JSON.stringify(result, null, 2));
+} else {
+  console.log('Usage: router.js <task description>');
+  console.log('\nAvailable agents:', Object.keys(AGENT_CAPABILITIES).join(', '));
+}
+
+module.exports = { routeTask, AGENT_CAPABILITIES, TASK_PATTERNS };

package/.claude/helpers/session.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * Claude Flow Session Manager
+ * Handles session lifecycle: start, restore, end
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SESSION_DIR = path.join(process.cwd(), '.claude-flow', 'sessions');
+const SESSION_FILE = path.join(SESSION_DIR, 'current.json');
+
+const commands = {
+  start: () => {
+    const sessionId = `session-${Date.now()}`;
+    const session = {
+      id: sessionId,
+      startedAt: new Date().toISOString(),
+      cwd: process.cwd(),
+      context: {},
+      metrics: {
+        edits: 0,
+        commands: 0,
+        tasks: 0,
+        errors: 0,
+      },
+    };
+
+    fs.mkdirSync(SESSION_DIR, { recursive: true });
+    fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+
+    console.log(`Session started: ${sessionId}`);
+    return session;
+  },
+
+  restore: () => {
+    if (!fs.existsSync(SESSION_FILE)) {
+      console.log('No session to restore');
+      return null;
+    }
+
+    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
+    session.restoredAt = new Date().toISOString();
+    fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+
+    console.log(`Session restored: ${session.id}`);
+    return session;
+  },
+
+  end: () => {
+    if (!fs.existsSync(SESSION_FILE)) {
+      console.log('No active session');
+      return null;
+    }
+
+    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
+    session.endedAt = new Date().toISOString();
+    session.duration = Date.now() - new Date(session.startedAt).getTime();
+
+    // Archive session
+    const archivePath = path.join(SESSION_DIR, `${session.id}.json`);
+    fs.writeFileSync(archivePath, JSON.stringify(session, null, 2));
+    fs.unlinkSync(SESSION_FILE);
+
+    console.log(`Session ended: ${session.id}`);
+    console.log(`Duration: ${Math.round(session.duration / 1000 / 60)} minutes`);
+    console.log(`Metrics: ${JSON.stringify(session.metrics)}`);
+
+    return session;
+  },
+
+  status: () => {
+    if (!fs.existsSync(SESSION_FILE)) {
+      console.log('No active session');
+      return null;
+    }
+
+    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
+    const duration = Date.now() - new Date(session.startedAt).getTime();
+
+    console.log(`Session: ${session.id}`);
+    console.log(`Started: ${session.startedAt}`);
+    console.log(`Duration: ${Math.round(duration / 1000 / 60)} minutes`);
+    console.log(`Metrics: ${JSON.stringify(session.metrics)}`);
+
+    return session;
+  },
+
+  update: (key, value) => {
+    if (!fs.existsSync(SESSION_FILE)) {
+      console.log('No active session');
+      return null;
+    }
+
+    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
+    session.context[key] = value;
+    session.updatedAt = new Date().toISOString();
+    fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+
+    return session;
+  },
+
+  metric: (name) => {
+    if (!fs.existsSync(SESSION_FILE)) {
+      return null;
+    }
+
+    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
+    if (session.metrics[name] !== undefined) {
+      session.metrics[name]++;
+      fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+    }
+
+    return session;
+  },
+};
+
+// CLI
+const [,, command, ...args] = process.argv;
+
+if (command && commands[command]) {
+  commands[command](...args);
+} else {
+  console.log('Usage: session.js <start|restore|end|status|update|metric> [args]');
+}
+
+module.exports = commands;

package/.claude/helpers/statusline-hook.sh

@@ -0,0 +1,21 @@
+# Claude Flow V3 Statusline Hook
+# Add to your shell RC file (.bashrc, .zshrc, etc.)
+
+# Function to get statusline
+claude_flow_statusline() {
+  local statusline_script="${CLAUDE_FLOW_DIR:-.claude}/helpers/statusline.js"
+  if [ -f "$statusline_script" ]; then
+    node "$statusline_script" 2>/dev/null || echo ""
+  fi
+}
+
+# For bash PS1
+# export PS1='$(claude_flow_statusline) \n\$ '
+
+# For zsh RPROMPT
+# export RPROMPT='$(claude_flow_statusline)'
+
+# For starship (add to starship.toml)
+# [custom.claude_flow]
+# command = "node .claude/helpers/statusline.js 2>/dev/null"
+# when = "test -f .claude/helpers/statusline.js"