claude-flow-guidance-implementation 0.1.0

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/settings.json

@@ -0,0 +1,250 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/helpers/hook-handler.cjs pre-bash",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/helpers/hook-handler.cjs post-edit",
+            "timeout": 10000
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/helpers/hook-handler.cjs route",
+            "timeout": 10000
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "startup|resume",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/helpers/hook-handler.cjs session-restore",
+            "timeout": 15000,
+            "continueOnError": true
+          },
+          {
+            "type": "command",
+            "command": "node .claude/helpers/auto-memory-hook.mjs import",
+            "timeout": 8000,
+            "continueOnError": true
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/helpers/hook-handler.cjs session-end",
+            "timeout": 10000,
+            "continueOnError": true
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/helpers/auto-memory-hook.mjs sync",
+            "timeout": 10000,
+            "continueOnError": true
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/helpers/hook-handler.cjs status",
+            "timeout": 3000,
+            "continueOnError": true
+          }
+        ]
+      }
+    ]
+  },
+  "statusLine": {
+    "type": "command",
+    "command": "node .claude/helpers/statusline.cjs",
+    "refreshMs": 5000,
+    "enabled": true
+  },
+  "permissions": {
+    "allow": [
+      "Bash(npx @claude-flow*)",
+      "Bash(npx claude-flow*)",
+      "Bash(node .claude/*)",
+      "mcp__claude-flow__:*"
+    ],
+    "deny": [
+      "Read(./.env)",
+      "Read(./.env.*)"
+    ]
+  },
+  "attribution": {
+    "commit": "Co-Authored-By: claude-flow <ruv@ruv.net>",
+    "pr": "🤖 Generated with [claude-flow](https://github.com/ruvnet/claude-flow)"
+  },
+  "env": {
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1",
+    "CLAUDE_FLOW_V3_ENABLED": "true",
+    "CLAUDE_FLOW_HOOKS_ENABLED": "true"
+  },
+  "claudeFlow": {
+    "version": "3.0.0",
+    "enabled": true,
+    "modelPreferences": {
+      "default": "claude-opus-4-6",
+      "routing": "claude-haiku-4-5-20251001"
+    },
+    "agentTeams": {
+      "enabled": true,
+      "teammateMode": "auto",
+      "taskListEnabled": true,
+      "mailboxEnabled": true,
+      "coordination": {
+        "autoAssignOnIdle": true,
+        "trainPatternsOnComplete": true,
+        "notifyLeadOnComplete": true,
+        "sharedMemoryNamespace": "agent-teams"
+      },
+      "hooks": {
+        "teammateIdle": {
+          "enabled": true,
+          "autoAssign": true,
+          "checkTaskList": true
+        },
+        "taskCompleted": {
+          "enabled": true,
+          "trainPatterns": true,
+          "notifyLead": true
+        }
+      }
+    },
+    "swarm": {
+      "topology": "hierarchical-mesh",
+      "maxAgents": 15
+    },
+    "memory": {
+      "backend": "hybrid",
+      "enableHNSW": true,
+      "learningBridge": {
+        "enabled": true
+      },
+      "memoryGraph": {
+        "enabled": true
+      },
+      "agentScopes": {
+        "enabled": true
+      }
+    },
+    "neural": {
+      "enabled": true
+    },
+    "daemon": {
+      "autoStart": true,
+      "workers": [
+        "map",
+        "audit",
+        "optimize",
+        "consolidate",
+        "testgaps",
+        "ultralearn",
+        "deepdive",
+        "document",
+        "refactor",
+        "benchmark"
+      ],
+      "schedules": {
+        "audit": {
+          "interval": "1h",
+          "priority": "critical"
+        },
+        "optimize": {
+          "interval": "30m",
+          "priority": "high"
+        },
+        "consolidate": {
+          "interval": "2h",
+          "priority": "low"
+        },
+        "document": {
+          "interval": "1h",
+          "priority": "normal",
+          "triggers": [
+            "adr-update",
+            "api-change"
+          ]
+        },
+        "deepdive": {
+          "interval": "4h",
+          "priority": "normal",
+          "triggers": [
+            "complex-change"
+          ]
+        },
+        "ultralearn": {
+          "interval": "1h",
+          "priority": "normal"
+        }
+      }
+    },
+    "learning": {
+      "enabled": true,
+      "autoTrain": true,
+      "patterns": [
+        "coordination",
+        "optimization",
+        "prediction"
+      ],
+      "retention": {
+        "shortTerm": "24h",
+        "longTerm": "30d"
+      }
+    },
+    "adr": {
+      "autoGenerate": true,
+      "directory": "/docs/adr",
+      "template": "madr"
+    },
+    "ddd": {
+      "trackDomains": true,
+      "validateBoundedContexts": true,
+      "directory": "/docs/ddd"
+    },
+    "security": {
+      "autoScan": true,
+      "scanOnEdit": true,
+      "cveCheck": true,
+      "threatModel": true
+    }
+  }
+}