@itz4blitz/agentful 1.2.0 → 1.3.0

package/template/bin/hooks/architect-drift-detector.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+/**
+ * Architect Drift Detector Hook
+ *
+ * Detects when project changes require architect to re-analyze and update skills/agents.
+ *
+ * Triggers re-analysis when:
+ * - New dependencies added (package.json, requirements.txt, go.mod, etc.)
+ * - Tech stack changes (switched frameworks)
+ * - New patterns emerge (5+ files violating existing conventions)
+ * - Skills are stale (last analysis > 7 days old)
+ *
+ * Run: After any Write/Edit operation by agents
+ * Action: Updates .agentful/architecture.json with needs_reanalysis: true
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+const ARCHITECTURE_FILE = '.agentful/architecture.json';
+const STALE_THRESHOLD_DAYS = 7;
+
+/**
+ * Detect if architect needs to re-run
+ */
+function detectArchitectDrift() {
+  try {
+    // Load current architecture analysis
+    const arch = loadArchitecture();
+
+    // Check various drift indicators
+    const driftReasons = [];
+
+    // 1. Check if dependency files changed
+    if (dependenciesChanged(arch)) {
+      driftReasons.push('dependencies_changed');
+    }
+
+    // 2. Check if tech stack files modified
+    if (techStackFilesModified(arch)) {
+      driftReasons.push('tech_stack_modified');
+    }
+
+    // 3. Check if analysis is stale
+    if (analysisIsStale(arch)) {
+      driftReasons.push('analysis_stale');
+    }
+
+    // 4. Check if new patterns emerged (heuristic: lots of new files)
+    if (newPatternsDetected(arch)) {
+      driftReasons.push('new_patterns_detected');
+    }
+
+    // If drift detected, mark for re-analysis
+    if (driftReasons.length > 0) {
+      markForReanalysis(arch, driftReasons);
+      console.log(`⚠️  Architect drift detected: ${driftReasons.join(', ')}`);
+      console.log('   Run /agentful-generate to update skills and agents');
+      return true;
+    }
+
+    return false;
+  } catch (error) {
+    // Fail silently - don't block operations if architecture.json missing
+    return false;
+  }
+}
+
+/**
+ * Load architecture.json
+ */
+function loadArchitecture() {
+  if (!fs.existsSync(ARCHITECTURE_FILE)) {
+    // First run - architect hasn't analyzed yet
+    return {
+      last_analysis: null,
+      dependency_hashes: {},
+      file_count: 0,
+      needs_reanalysis: true
+    };
+  }
+
+  return JSON.parse(fs.readFileSync(ARCHITECTURE_FILE, 'utf8'));
+}
+
+/**
+ * Check if dependency files changed
+ */
+function dependenciesChanged(arch) {
+  const depFiles = [
+    'package.json',
+    'package-lock.json',
+    'requirements.txt',
+    'pyproject.toml',
+    'Pipfile',
+    'go.mod',
+    'go.sum',
+    'Gemfile',
+    'Gemfile.lock',
+    'composer.json',
+    'pom.xml',
+    'build.gradle',
+    'Cargo.toml'
+  ];
+
+  for (const file of depFiles) {
+    if (!fs.existsSync(file)) continue;
+
+    const currentHash = hashFile(file);
+    const previousHash = arch.dependency_hashes?.[file];
+
+    if (previousHash && currentHash !== previousHash) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if tech stack config files modified
+ */
+function techStackFilesModified(arch) {
+  const configFiles = [
+    'tsconfig.json',
+    'next.config.js',
+    'vite.config.js',
+    'webpack.config.js',
+    'django/settings.py',
+    'config/application.rb',
+    'nest-cli.json'
+  ];
+
+  for (const file of configFiles) {
+    if (!fs.existsSync(file)) continue;
+
+    const currentHash = hashFile(file);
+    const previousHash = arch.dependency_hashes?.[file];
+
+    if (previousHash && currentHash !== previousHash) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if analysis is stale (>7 days old)
+ */
+function analysisIsStale(arch) {
+  if (!arch.last_analysis) return true;
+
+  const lastAnalysis = new Date(arch.last_analysis);
+  const daysSinceAnalysis = (Date.now() - lastAnalysis.getTime()) / (1000 * 60 * 60 * 24);
+
+  return daysSinceAnalysis > STALE_THRESHOLD_DAYS;
+}
+
+/**
+ * Heuristic: Check if significant new code added (potential new patterns)
+ */
+function newPatternsDetected(arch) {
+  // Count current files in src/
+  const currentFileCount = countSourceFiles();
+  const previousFileCount = arch.file_count || 0;
+
+  // If 20% more files added, might have new patterns
+  const growthRatio = (currentFileCount - previousFileCount) / Math.max(previousFileCount, 1);
+
+  return growthRatio > 0.2;
+}
+
+/**
+ * Count source files
+ */
+function countSourceFiles() {
+  const srcDirs = ['src', 'app', 'lib', 'pages', 'components'];
+  let count = 0;
+
+  for (const dir of srcDirs) {
+    if (fs.existsSync(dir)) {
+      count += countFilesRecursive(dir);
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Count files recursively
+ */
+function countFilesRecursive(dir) {
+  let count = 0;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue;
+    if (entry.name === 'node_modules') continue;
+
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      count += countFilesRecursive(fullPath);
+    } else if (entry.isFile()) {
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Hash a file
+ */
+function hashFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return crypto.createHash('md5').update(content).digest('hex');
+}
+
+/**
+ * Mark architecture.json for re-analysis
+ */
+function markForReanalysis(arch, reasons) {
+  arch.needs_reanalysis = true;
+  arch.drift_reasons = reasons;
+  arch.drift_detected_at = new Date().toISOString();
+
+  // Ensure directory exists
+  const dir = path.dirname(ARCHITECTURE_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(ARCHITECTURE_FILE, JSON.stringify(arch, null, 2));
+}
+
+// Run detection
+const driftDetected = detectArchitectDrift();
+process.exit(driftDetected ? 1 : 0);

package/template/bin/hooks/product-spec-watcher.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+/**
+ * Product Spec Watcher Hook
+ *
+ * Triggered on Write/Edit of .claude/product/**.md files
+ * Auto-triggers /agentful-generate when product spec is updated
+ *
+ * Use case:
+ * 1. User runs /agentful-init → creates .claude/product/index.md
+ * 2. This hook detects the file creation
+ * 3. Checks if from /agentful-init flow
+ * 4. Auto-triggers agent generation with BOTH tech stack + requirements
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Get tool use metadata from environment
+const toolUseEnv = process.env.CLAUDE_TOOL_USE || '{}';
+let toolUse;
+
+try {
+  toolUse = JSON.parse(toolUseEnv);
+} catch (error) {
+  // Invalid JSON - exit silently
+  process.exit(0);
+}
+
+// Get the file path that was written/edited
+const filePath = toolUse.parameters?.file_path || '';
+
+// Only trigger on product spec files
+if (!filePath.includes('.claude/product/')) {
+  process.exit(0);
+}
+
+// Get the root directory
+const getRepoRoot = () => {
+  try {
+    const { execSync } = require('child_process');
+    return execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf8'
+    }).trim();
+  } catch {
+    // Not a git repo - use cwd
+    return process.cwd();
+  }
+};
+
+const repoRoot = getRepoRoot();
+const setupProgressPath = path.join(repoRoot, '.agentful', 'setup-progress.json');
+const architecturePath = path.join(repoRoot, '.agentful', 'architecture.json');
+
+// Check if this is from /agentful-init flow
+let isFromInit = false;
+let setupProgress = null;
+
+if (fs.existsSync(setupProgressPath)) {
+  try {
+    setupProgress = JSON.parse(fs.readFileSync(setupProgressPath, 'utf8'));
+
+    // Check if setup just completed but agents not yet generated
+    isFromInit = setupProgress.completed &&
+                 !setupProgress.agents_generated &&
+                 // Must be recent (within last 5 minutes)
+                 (Date.now() - new Date(setupProgress.timestamp).getTime()) < 5 * 60 * 1000;
+  } catch (error) {
+    // Ignore JSON parse errors
+  }
+}
+
+// Check if agents already exist
+const hasExistingAgents = fs.existsSync(architecturePath);
+
+if (isFromInit && !hasExistingAgents) {
+  console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   Product Specification Updated
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+File: ${path.relative(repoRoot, filePath)}
+
+Auto-triggering agent generation with:
+  ✓ Tech stack (detected)
+  ✓ Product requirements (from /agentful-init)
+
+This ensures specialized agents are tailored to your product.
+
+Starting analysis...
+`);
+
+  // Mark that we're about to generate agents
+  if (setupProgress) {
+    setupProgress.agents_generation_triggered = true;
+    setupProgress.agents_generation_timestamp = new Date().toISOString();
+
+    try {
+      fs.writeFileSync(setupProgressPath, JSON.stringify(setupProgress, null, 2));
+    } catch (error) {
+      // Non-fatal - continue anyway
+    }
+  }
+
+  // NOTE: The actual triggering of /agentful-generate would happen here
+  // This depends on Claude Code's slash command triggering system
+  // For now, we just notify the user
+
+  console.log(`
+⏭️  Next: Agent generation will continue automatically.
+
+If it doesn't start automatically, run:
+  /agentful-generate
+`);
+
+} else if (!isFromInit && !hasExistingAgents) {
+  // Manual edit of product spec, but no agents yet
+  console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   Product Specification Updated
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+File: ${path.relative(repoRoot, filePath)}
+
+To generate specialized agents based on your product spec:
+  /agentful-generate
+
+Or to use the guided setup:
+  /agentful-init
+`);
+
+} else if (hasExistingAgents) {
+  // Agents already exist - notify about regeneration
+  console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   Product Specification Updated
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+File: ${path.relative(repoRoot, filePath)}
+
+Your product spec changed, but agents already exist.
+
+To regenerate agents with updated requirements:
+  /agentful-generate
+
+Or continue with existing agents:
+  /agentful-start
+`);
+}
+
+process.exit(0);

package/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.1.0"
+  "version": "1.2.2"
 }

package/bin/hooks/post-agent.js

@@ -1,101 +0,0 @@
-#!/usr/bin/env node
-// post-agent.js
-// Tracks agent execution metrics
-
-import fs from 'fs';
-
-const METRICS_FILE = '.agentful/agent-metrics.json';
-
-/**
- * Track agent execution metrics
- * @param {Object} options - Tracking options
- * @param {string} options.agentName - Name of the agent
- * @param {string} [options.feature] - Feature being worked on
- * @param {string} [options.domain] - Domain context
- * @param {string} [options.timestamp] - ISO timestamp (defaults to current time)
- * @returns {Object} - Result with success flag and optional error
- */
-export function trackAgentMetrics({ agentName, feature = '', domain = '', timestamp = new Date().toISOString() }) {
-  // Exit successfully if no agent specified
-  if (!agentName) {
-    return { success: true };
-  }
-
-  // Ensure .agentful directory exists
-  const metricsDir = METRICS_FILE.substring(0, METRICS_FILE.lastIndexOf('/'));
-  if (!fs.existsSync(metricsDir)) {
-    fs.mkdirSync(metricsDir, { recursive: true });
-  }
-
-  // Create metrics file if it doesn't exist
-  if (!fs.existsSync(METRICS_FILE)) {
-    const initialMetrics = {
-      invocations: {},
-      last_invocation: null,
-      feature_hooks: []
-    };
-    fs.writeFileSync(METRICS_FILE, JSON.stringify(initialMetrics, null, 2));
-  }
-
-  // Validate and read existing metrics file
-  let metrics;
-  if (!fs.existsSync(METRICS_FILE)) {
-    // File doesn't exist, create new structure
-    metrics = {
-      invocations: {},
-      last_invocation: null,
-      feature_hooks: []
-    };
-  } else {
-    try {
-      const metricsContent = fs.readFileSync(METRICS_FILE, 'utf8');
-      metrics = JSON.parse(metricsContent);
-    } catch (err) {
-      console.log('WARNING: agent-metrics.json is corrupted, recreating');
-      metrics = {
-        invocations: {},
-        last_invocation: null,
-        feature_hooks: []
-      };
-    }
-  }
-
-  // Update invocation count for this agent
-  const currentCount = metrics.invocations[agentName] || 0;
-  const newCount = currentCount + 1;
-
-  // Update metrics
-  metrics.invocations[agentName] = newCount;
-  metrics.last_invocation = {
-    agent: agentName,
-    timestamp: timestamp,
-    feature: feature,
-    domain: domain
-  };
-
-  // Write updated metrics
-  try {
-    fs.writeFileSync(METRICS_FILE, JSON.stringify(metrics, null, 2));
-    return { success: true };
-  } catch (err) {
-    console.error('WARNING: Failed to write agent-metrics.json');
-    return { success: true, error: err.message };
-  }
-}
-
-// CLI entrypoint
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const AGENT_NAME = process.env.AGENTFUL_AGENT || '';
-  const FEATURE = process.env.AGENTFUL_FEATURE || '';
-  const DOMAIN = process.env.AGENTFUL_DOMAIN || '';
-  const TIMESTAMP = new Date().toISOString();
-
-  trackAgentMetrics({
-    agentName: AGENT_NAME,
-    feature: FEATURE,
-    domain: DOMAIN,
-    timestamp: TIMESTAMP
-  });
-
-  process.exit(0);
-}