@weavelogic/knowledge-graph-agent 0.2.0 → 0.4.0

package/dist/cultivation/deep-analyzer.d.ts

@@ -0,0 +1,129 @@
+/**
+ * DeepAnalyzer - Claude-Flow Integration for Deep Codebase Analysis
+ *
+ * Uses claude-flow agents for comprehensive codebase analysis:
+ * - Pattern detection and architectural insights
+ * - Documentation gap analysis
+ * - Standards compliance checking
+ *
+ * @module cultivation/deep-analyzer
+ */
+/**
+ * Deep analyzer options
+ */
+export interface DeepAnalyzerOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Documentation path (relative to project root) */
+    docsPath?: string;
+    /** Output directory for analysis results */
+    outputDir?: string;
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Maximum agents to spawn */
+    maxAgents?: number;
+    /** Agent execution mode */
+    agentMode?: 'sequential' | 'parallel' | 'adaptive';
+    /** Timeout for each agent (ms) */
+    agentTimeout?: number;
+}
+/**
+ * Analysis result from an agent
+ */
+export interface AgentResult {
+    name: string;
+    type: string;
+    success: boolean;
+    insights: string[];
+    documents: Array<{
+        path: string;
+        title: string;
+    }>;
+    duration: number;
+    error?: string;
+}
+/**
+ * Deep analysis result
+ */
+export interface DeepAnalysisResult {
+    success: boolean;
+    agentsSpawned: number;
+    insightsCount: number;
+    documentsCreated: number;
+    results: AgentResult[];
+    duration: number;
+    errors: string[];
+}
+/**
+ * DeepAnalyzer - Uses claude-flow for deep codebase analysis
+ *
+ * @example
+ * ```typescript
+ * const analyzer = new DeepAnalyzer({
+ *   projectRoot: '/my/project',
+ *   docsPath: 'docs',
+ * });
+ *
+ * const result = await analyzer.analyze();
+ * console.log(`Generated ${result.insightsCount} insights`);
+ * ```
+ */
+export declare class DeepAnalyzer {
+    private projectRoot;
+    private docsPath;
+    private outputDir;
+    private verbose;
+    private maxAgents;
+    private agentMode;
+    private agentTimeout;
+    constructor(options: DeepAnalyzerOptions);
+    /**
+     * Check if claude-flow is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Run deep analysis
+     */
+    analyze(): Promise<DeepAnalysisResult>;
+    /**
+     * Execute agents in parallel
+     */
+    private executeParallel;
+    /**
+     * Execute agents sequentially
+     */
+    private executeSequential;
+    /**
+     * Execute agents adaptively (start with 2, scale based on success)
+     */
+    private executeAdaptive;
+    /**
+     * Execute a single agent
+     */
+    private executeAgent;
+    /**
+     * Build prompt for agent
+     */
+    private buildPrompt;
+    /**
+     * Run claude-flow agent
+     */
+    private runClaudeFlowAgent;
+    /**
+     * Extract insights from agent output
+     */
+    private extractInsights;
+    /**
+     * Format output for documentation
+     */
+    private formatOutput;
+}
+/**
+ * Create a deep analyzer instance
+ */
+export declare function createDeepAnalyzer(options: DeepAnalyzerOptions): DeepAnalyzer;
+/**
+ * Run deep analysis on a project
+ */
+export declare function analyzeDeep(projectRoot: string, docsPath?: string): Promise<DeepAnalysisResult>;
+//# sourceMappingURL=deep-analyzer.d.ts.map

package/dist/cultivation/deep-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-analyzer.d.ts","sourceRoot":"","sources":["../../src/cultivation/deep-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAsBH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,6BAA6B;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,8BAA8B;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,SAAS,CAAC,EAAE,YAAY,GAAG,UAAU,GAAG,UAAU,CAAC;IACnD,kCAAkC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAYD;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,YAAY,CAAS;gBAEjB,OAAO,EAAE,mBAAmB;IAWxC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAerC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAyF5C;;OAEG;YACW,eAAe;IAK7B;;OAEG;YACW,iBAAiB;IAQ/B;;OAEG;YACW,eAAe;IA2B7B;;OAEG;YACW,YAAY;IA0C1B;;OAEG;IACH,OAAO,CAAC,WAAW;IA8BnB;;OAEG;YACW,kBAAkB;IA2ChC;;OAEG;IACH,OAAO,CAAC,eAAe;IAuBvB;;OAEG;IACH,OAAO,CAAC,YAAY;CA4BrB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAE7E;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,kBAAkB,CAAC,CAG7B"}

package/dist/cultivation/deep-analyzer.js

@@ -0,0 +1,322 @@
+import { execFileSync, spawn } from "child_process";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve, join } from "path";
+import { createLogger } from "../utils/logger.js";
+const logger = createLogger("deep-analyzer");
+const VALID_AGENT_TYPES = /* @__PURE__ */ new Set([
+  "researcher",
+  "architect",
+  "analyst",
+  "coder",
+  "tester",
+  "reviewer",
+  "documenter"
+]);
+class DeepAnalyzer {
+  projectRoot;
+  docsPath;
+  outputDir;
+  verbose;
+  maxAgents;
+  agentMode;
+  agentTimeout;
+  constructor(options) {
+    this.projectRoot = resolve(options.projectRoot);
+    this.docsPath = options.docsPath || "docs";
+    this.outputDir = options.outputDir || join(this.projectRoot, this.docsPath, "analysis");
+    this.verbose = options.verbose || false;
+    this.maxAgents = options.maxAgents || 5;
+    this.agentMode = options.agentMode || "adaptive";
+    this.agentTimeout = options.agentTimeout || 6e4;
+  }
+  /**
+   * Check if claude-flow is available
+   */
+  async isAvailable() {
+    try {
+      execFileSync("npx", ["claude-flow@alpha", "--version"], {
+        stdio: "pipe",
+        timeout: 5e3,
+        windowsHide: true
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Run deep analysis
+   */
+  async analyze() {
+    const startTime = Date.now();
+    const result = {
+      success: false,
+      agentsSpawned: 0,
+      insightsCount: 0,
+      documentsCreated: 0,
+      results: [],
+      duration: 0,
+      errors: []
+    };
+    if (!await this.isAvailable()) {
+      result.errors.push("claude-flow is not available");
+      result.duration = Date.now() - startTime;
+      return result;
+    }
+    if (!existsSync(this.outputDir)) {
+      mkdirSync(this.outputDir, { recursive: true });
+    }
+    const agents = [
+      {
+        name: "Pattern Researcher",
+        type: "researcher",
+        task: "Analyze codebase architecture, patterns, and design decisions",
+        outputFile: "architecture-patterns.md"
+      },
+      {
+        name: "Code Analyst",
+        type: "analyst",
+        task: "Identify code quality issues, complexity hotspots, and improvement opportunities",
+        outputFile: "code-analysis.md"
+      },
+      {
+        name: "Implementation Reviewer",
+        type: "coder",
+        task: "Review implementation patterns, naming conventions, and code style",
+        outputFile: "implementation-review.md"
+      },
+      {
+        name: "Test Analyzer",
+        type: "tester",
+        task: "Analyze test coverage, testing patterns, and testing gaps",
+        outputFile: "testing-analysis.md"
+      }
+    ];
+    logger.info("Starting deep analysis", { agents: agents.length, mode: this.agentMode });
+    if (this.agentMode === "parallel") {
+      result.results = await this.executeParallel(agents);
+    } else if (this.agentMode === "sequential") {
+      result.results = await this.executeSequential(agents);
+    } else {
+      result.results = await this.executeAdaptive(agents);
+    }
+    result.agentsSpawned = result.results.length;
+    result.insightsCount = result.results.reduce((sum, r) => sum + r.insights.length, 0);
+    result.documentsCreated = result.results.reduce((sum, r) => sum + r.documents.length, 0);
+    result.success = result.results.every((r) => r.success);
+    result.duration = Date.now() - startTime;
+    for (const agentResult of result.results) {
+      if (agentResult.error) {
+        result.errors.push(`${agentResult.name}: ${agentResult.error}`);
+      }
+    }
+    logger.info("Deep analysis complete", {
+      success: result.success,
+      insights: result.insightsCount,
+      documents: result.documentsCreated,
+      duration: result.duration
+    });
+    return result;
+  }
+  /**
+   * Execute agents in parallel
+   */
+  async executeParallel(agents) {
+    const promises = agents.map((agent) => this.executeAgent(agent));
+    return Promise.all(promises);
+  }
+  /**
+   * Execute agents sequentially
+   */
+  async executeSequential(agents) {
+    const results = [];
+    for (const agent of agents) {
+      results.push(await this.executeAgent(agent));
+    }
+    return results;
+  }
+  /**
+   * Execute agents adaptively (start with 2, scale based on success)
+   */
+  async executeAdaptive(agents) {
+    const results = [];
+    const firstBatch = agents.slice(0, 2);
+    const firstResults = await Promise.all(firstBatch.map((a) => this.executeAgent(a)));
+    results.push(...firstResults);
+    const successRate = firstResults.filter((r) => r.success).length / firstResults.length;
+    if (successRate >= 0.5 && agents.length > 2) {
+      const remaining = agents.slice(2);
+      const remainingResults = await Promise.all(remaining.map((a) => this.executeAgent(a)));
+      results.push(...remainingResults);
+    } else if (agents.length > 2) {
+      logger.warn("Low success rate, switching to sequential mode");
+      for (const agent of agents.slice(2)) {
+        results.push(await this.executeAgent(agent));
+      }
+    }
+    return results;
+  }
+  /**
+   * Execute a single agent
+   */
+  async executeAgent(agent) {
+    const startTime = Date.now();
+    const outputPath = join(this.outputDir, agent.outputFile);
+    const result = {
+      name: agent.name,
+      type: agent.type,
+      success: false,
+      insights: [],
+      documents: [],
+      duration: 0
+    };
+    try {
+      logger.info(`Spawning agent: ${agent.name}`, { type: agent.type });
+      const prompt = this.buildPrompt(agent);
+      const output = await this.runClaudeFlowAgent(agent.type, prompt);
+      result.insights = this.extractInsights(output);
+      writeFileSync(outputPath, this.formatOutput(agent, output));
+      result.documents.push({ path: outputPath, title: agent.name });
+      result.success = true;
+      if (this.verbose) {
+        logger.debug(`Agent completed: ${agent.name}`, { insights: result.insights.length });
+      }
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : String(error);
+      logger.error(`Agent failed: ${agent.name}`, error instanceof Error ? error : new Error(String(error)));
+    }
+    result.duration = Date.now() - startTime;
+    return result;
+  }
+  /**
+   * Build prompt for agent
+   */
+  buildPrompt(agent) {
+    return `You are a ${agent.name} analyzing the project at ${this.projectRoot}.
+
+**OBJECTIVE**: ${agent.task}
+
+**COORDINATION PROTOCOL**:
+\`\`\`bash
+npx claude-flow@alpha hooks pre-task --description "${agent.task}"
+\`\`\`
+
+**YOUR TASKS**:
+1. Analyze the codebase at ${this.projectRoot}
+2. Identify key patterns and conventions
+3. Document your findings with specific examples
+4. Provide actionable recommendations
+5. Generate comprehensive markdown documentation
+
+**OUTPUT REQUIREMENTS**:
+- Use clear markdown formatting
+- Include code examples from the project
+- Organize findings by category
+- Prioritize actionable insights
+
+After completing:
+\`\`\`bash
+npx claude-flow@alpha hooks post-task --task-id "${agent.type}-analysis"
+\`\`\`
+`;
+  }
+  /**
+   * Run claude-flow agent
+   */
+  async runClaudeFlowAgent(type, prompt) {
+    if (!VALID_AGENT_TYPES.has(type)) {
+      throw new Error(`Invalid agent type: ${type}. Valid types: ${[...VALID_AGENT_TYPES].join(", ")}`);
+    }
+    const sanitizedPrompt = prompt.replace(/[`$\\]/g, "");
+    return new Promise((resolve2, reject) => {
+      const args = ["claude-flow@alpha", "agent", "execute", type, sanitizedPrompt, "--json"];
+      const proc = spawn("npx", args, {
+        cwd: this.projectRoot,
+        shell: false,
+        // Security: Disable shell to prevent command injection
+        timeout: this.agentTimeout
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve2(stdout);
+        } else {
+          reject(new Error(stderr || `Agent exited with code ${code}`));
+        }
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Extract insights from agent output
+   */
+  extractInsights(output) {
+    const insights = [];
+    const patterns = [
+      /[-*]\s*(?:insight|finding|observation|recommendation):\s*(.+)/gi,
+      /##\s*(?:insight|finding|observation|recommendation):\s*(.+)/gi,
+      /(?:key\s+)?(?:insight|finding|observation|recommendation):\s*(.+)/gi
+    ];
+    for (const pattern of patterns) {
+      const matches = output.matchAll(pattern);
+      for (const match of matches) {
+        if (match[1]) {
+          insights.push(match[1].trim());
+        }
+      }
+    }
+    return [...new Set(insights)];
+  }
+  /**
+   * Format output for documentation
+   */
+  formatOutput(agent, output) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `---
+title: "${agent.name} Analysis"
+type: analysis
+generator: deep-analyzer
+agent: ${agent.type}
+created: ${timestamp}
+---
+
+# ${agent.name} Analysis
+
+> Generated by DeepAnalyzer using claude-flow
+
+## Overview
+
+${agent.task}
+
+## Analysis
+
+${output}
+
+---
+
+*Generated on ${(/* @__PURE__ */ new Date()).toLocaleString()}*
+`;
+  }
+}
+function createDeepAnalyzer(options) {
+  return new DeepAnalyzer(options);
+}
+async function analyzeDeep(projectRoot, docsPath) {
+  const analyzer = new DeepAnalyzer({ projectRoot, docsPath });
+  return analyzer.analyze();
+}
+export {
+  DeepAnalyzer,
+  analyzeDeep,
+  createDeepAnalyzer
+};
+//# sourceMappingURL=deep-analyzer.js.map

package/dist/cultivation/deep-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-analyzer.js","sources":["../../src/cultivation/deep-analyzer.ts"],"sourcesContent":["/**\n * DeepAnalyzer - Claude-Flow Integration for Deep Codebase Analysis\n *\n * Uses claude-flow agents for comprehensive codebase analysis:\n * - Pattern detection and architectural insights\n * - Documentation gap analysis\n * - Standards compliance checking\n *\n * @module cultivation/deep-analyzer\n */\n\nimport { execFileSync, spawn } from 'child_process';\nimport { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';\nimport { join, resolve } from 'path';\nimport { createLogger } from '../utils/index.js';\n\nconst logger = createLogger('deep-analyzer');\n\n/**\n * Valid agent types for security validation\n */\nconst VALID_AGENT_TYPES = new Set([\n  'researcher',\n  'architect',\n  'analyst',\n  'coder',\n  'tester',\n  'reviewer',\n  'documenter',\n]);\n\n/**\n * Deep analyzer options\n */\nexport interface DeepAnalyzerOptions {\n  /** Project root directory */\n  projectRoot: string;\n  /** Documentation path (relative to project root) */\n  docsPath?: string;\n  /** Output directory for analysis results */\n  outputDir?: string;\n  /** Enable verbose logging */\n  verbose?: boolean;\n  /** Maximum agents to spawn */\n  maxAgents?: number;\n  /** Agent execution mode */\n  agentMode?: 'sequential' | 'parallel' | 'adaptive';\n  /** Timeout for each agent (ms) */\n  agentTimeout?: number;\n}\n\n/**\n * Analysis result from an agent\n */\nexport interface AgentResult {\n  name: string;\n  type: string;\n  success: boolean;\n  insights: string[];\n  documents: Array<{ path: string; title: string }>;\n  duration: number;\n  error?: string;\n}\n\n/**\n * Deep analysis result\n */\nexport interface DeepAnalysisResult {\n  success: boolean;\n  agentsSpawned: number;\n  insightsCount: number;\n  documentsCreated: number;\n  results: AgentResult[];\n  duration: number;\n  errors: string[];\n}\n\n/**\n * Agent configuration\n */\ninterface AgentConfig {\n  name: string;\n  type: 'researcher' | 'analyst' | 'coder' | 'tester' | 'reviewer';\n  task: string;\n  outputFile: string;\n}\n\n/**\n * DeepAnalyzer - Uses claude-flow for deep codebase analysis\n *\n * @example\n * ```typescript\n * const analyzer = new DeepAnalyzer({\n *   projectRoot: '/my/project',\n *   docsPath: 'docs',\n * });\n *\n * const result = await analyzer.analyze();\n * console.log(`Generated ${result.insightsCount} insights`);\n * ```\n */\nexport class DeepAnalyzer {\n  private projectRoot: string;\n  private docsPath: string;\n  private outputDir: string;\n  private verbose: boolean;\n  private maxAgents: number;\n  private agentMode: 'sequential' | 'parallel' | 'adaptive';\n  private agentTimeout: number;\n\n  constructor(options: DeepAnalyzerOptions) {\n    this.projectRoot = resolve(options.projectRoot);\n    this.docsPath = options.docsPath || 'docs';\n    this.outputDir = options.outputDir || join(this.projectRoot, this.docsPath, 'analysis');\n    this.verbose = options.verbose || false;\n    this.maxAgents = options.maxAgents || 5;\n    this.agentMode = options.agentMode || 'adaptive';\n    // Default timeout of 60 seconds (configurable via agentTimeout option)\n    this.agentTimeout = options.agentTimeout || 60000;\n  }\n\n  /**\n   * Check if claude-flow is available\n   */\n  async isAvailable(): Promise<boolean> {\n    try {\n      // SECURITY: execFileSync does not spawn a shell by default, preventing shell injection\n      // Using npx with explicit arguments avoids shell metacharacter interpretation\n      execFileSync('npx', ['claude-flow@alpha', '--version'], {\n        stdio: 'pipe',\n        timeout: 5000,\n        windowsHide: true,\n      });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Run deep analysis\n   */\n  async analyze(): Promise<DeepAnalysisResult> {\n    const startTime = Date.now();\n\n    const result: DeepAnalysisResult = {\n      success: false,\n      agentsSpawned: 0,\n      insightsCount: 0,\n      documentsCreated: 0,\n      results: [],\n      duration: 0,\n      errors: [],\n    };\n\n    // Check availability\n    if (!(await this.isAvailable())) {\n      result.errors.push('claude-flow is not available');\n      result.duration = Date.now() - startTime;\n      return result;\n    }\n\n    // Ensure output directory exists\n    if (!existsSync(this.outputDir)) {\n      mkdirSync(this.outputDir, { recursive: true });\n    }\n\n    // Define agents\n    const agents: AgentConfig[] = [\n      {\n        name: 'Pattern Researcher',\n        type: 'researcher',\n        task: 'Analyze codebase architecture, patterns, and design decisions',\n        outputFile: 'architecture-patterns.md',\n      },\n      {\n        name: 'Code Analyst',\n        type: 'analyst',\n        task: 'Identify code quality issues, complexity hotspots, and improvement opportunities',\n        outputFile: 'code-analysis.md',\n      },\n      {\n        name: 'Implementation Reviewer',\n        type: 'coder',\n        task: 'Review implementation patterns, naming conventions, and code style',\n        outputFile: 'implementation-review.md',\n      },\n      {\n        name: 'Test Analyzer',\n        type: 'tester',\n        task: 'Analyze test coverage, testing patterns, and testing gaps',\n        outputFile: 'testing-analysis.md',\n      },\n    ];\n\n    logger.info('Starting deep analysis', { agents: agents.length, mode: this.agentMode });\n\n    // Execute agents based on mode\n    if (this.agentMode === 'parallel') {\n      result.results = await this.executeParallel(agents);\n    } else if (this.agentMode === 'sequential') {\n      result.results = await this.executeSequential(agents);\n    } else {\n      // Adaptive: start with 2, scale based on success\n      result.results = await this.executeAdaptive(agents);\n    }\n\n    // Calculate totals\n    result.agentsSpawned = result.results.length;\n    result.insightsCount = result.results.reduce((sum, r) => sum + r.insights.length, 0);\n    result.documentsCreated = result.results.reduce((sum, r) => sum + r.documents.length, 0);\n    result.success = result.results.every(r => r.success);\n    result.duration = Date.now() - startTime;\n\n    // Collect errors\n    for (const agentResult of result.results) {\n      if (agentResult.error) {\n        result.errors.push(`${agentResult.name}: ${agentResult.error}`);\n      }\n    }\n\n    logger.info('Deep analysis complete', {\n      success: result.success,\n      insights: result.insightsCount,\n      documents: result.documentsCreated,\n      duration: result.duration,\n    });\n\n    return result;\n  }\n\n  /**\n   * Execute agents in parallel\n   */\n  private async executeParallel(agents: AgentConfig[]): Promise<AgentResult[]> {\n    const promises = agents.map(agent => this.executeAgent(agent));\n    return Promise.all(promises);\n  }\n\n  /**\n   * Execute agents sequentially\n   */\n  private async executeSequential(agents: AgentConfig[]): Promise<AgentResult[]> {\n    const results: AgentResult[] = [];\n    for (const agent of agents) {\n      results.push(await this.executeAgent(agent));\n    }\n    return results;\n  }\n\n  /**\n   * Execute agents adaptively (start with 2, scale based on success)\n   */\n  private async executeAdaptive(agents: AgentConfig[]): Promise<AgentResult[]> {\n    const results: AgentResult[] = [];\n\n    // First batch: 2 agents\n    const firstBatch = agents.slice(0, 2);\n    const firstResults = await Promise.all(firstBatch.map(a => this.executeAgent(a)));\n    results.push(...firstResults);\n\n    // Check success rate\n    const successRate = firstResults.filter(r => r.success).length / firstResults.length;\n\n    if (successRate >= 0.5 && agents.length > 2) {\n      // Continue with remaining agents in parallel\n      const remaining = agents.slice(2);\n      const remainingResults = await Promise.all(remaining.map(a => this.executeAgent(a)));\n      results.push(...remainingResults);\n    } else if (agents.length > 2) {\n      // Fall back to sequential\n      logger.warn('Low success rate, switching to sequential mode');\n      for (const agent of agents.slice(2)) {\n        results.push(await this.executeAgent(agent));\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * Execute a single agent\n   */\n  private async executeAgent(agent: AgentConfig): Promise<AgentResult> {\n    const startTime = Date.now();\n    const outputPath = join(this.outputDir, agent.outputFile);\n\n    const result: AgentResult = {\n      name: agent.name,\n      type: agent.type,\n      success: false,\n      insights: [],\n      documents: [],\n      duration: 0,\n    };\n\n    try {\n      logger.info(`Spawning agent: ${agent.name}`, { type: agent.type });\n\n      const prompt = this.buildPrompt(agent);\n\n      // Execute claude-flow agent\n      const output = await this.runClaudeFlowAgent(agent.type, prompt);\n\n      // Parse output for insights\n      result.insights = this.extractInsights(output);\n\n      // Write output to file\n      writeFileSync(outputPath, this.formatOutput(agent, output));\n      result.documents.push({ path: outputPath, title: agent.name });\n\n      result.success = true;\n\n      if (this.verbose) {\n        logger.debug(`Agent completed: ${agent.name}`, { insights: result.insights.length });\n      }\n    } catch (error) {\n      result.error = error instanceof Error ? error.message : String(error);\n      logger.error(`Agent failed: ${agent.name}`, error instanceof Error ? error : new Error(String(error)));\n    }\n\n    result.duration = Date.now() - startTime;\n    return result;\n  }\n\n  /**\n   * Build prompt for agent\n   */\n  private buildPrompt(agent: AgentConfig): string {\n    return `You are a ${agent.name} analyzing the project at ${this.projectRoot}.\n\n**OBJECTIVE**: ${agent.task}\n\n**COORDINATION PROTOCOL**:\n\\`\\`\\`bash\nnpx claude-flow@alpha hooks pre-task --description \"${agent.task}\"\n\\`\\`\\`\n\n**YOUR TASKS**:\n1. Analyze the codebase at ${this.projectRoot}\n2. Identify key patterns and conventions\n3. Document your findings with specific examples\n4. Provide actionable recommendations\n5. Generate comprehensive markdown documentation\n\n**OUTPUT REQUIREMENTS**:\n- Use clear markdown formatting\n- Include code examples from the project\n- Organize findings by category\n- Prioritize actionable insights\n\nAfter completing:\n\\`\\`\\`bash\nnpx claude-flow@alpha hooks post-task --task-id \"${agent.type}-analysis\"\n\\`\\`\\`\n`;\n  }\n\n  /**\n   * Run claude-flow agent\n   */\n  private async runClaudeFlowAgent(type: string, prompt: string): Promise<string> {\n    // Security: Validate agent type against allowlist to prevent command injection\n    if (!VALID_AGENT_TYPES.has(type)) {\n      throw new Error(`Invalid agent type: ${type}. Valid types: ${[...VALID_AGENT_TYPES].join(', ')}`);\n    }\n\n    // Security: Sanitize prompt to prevent injection via shell metacharacters\n    const sanitizedPrompt = prompt.replace(/[`$\\\\]/g, '');\n\n    return new Promise((resolve, reject) => {\n      const args = ['claude-flow@alpha', 'agent', 'execute', type, sanitizedPrompt, '--json'];\n\n      const proc = spawn('npx', args, {\n        cwd: this.projectRoot,\n        shell: false, // Security: Disable shell to prevent command injection\n        timeout: this.agentTimeout,\n      });\n\n      let stdout = '';\n      let stderr = '';\n\n      proc.stdout?.on('data', (data) => {\n        stdout += data.toString();\n      });\n\n      proc.stderr?.on('data', (data) => {\n        stderr += data.toString();\n      });\n\n      proc.on('close', (code) => {\n        if (code === 0) {\n          resolve(stdout);\n        } else {\n          reject(new Error(stderr || `Agent exited with code ${code}`));\n        }\n      });\n\n      proc.on('error', (error) => {\n        reject(error);\n      });\n    });\n  }\n\n  /**\n   * Extract insights from agent output\n   */\n  private extractInsights(output: string): string[] {\n    const insights: string[] = [];\n\n    // Look for patterns like \"- Insight:\" or \"## Finding:\"\n    const patterns = [\n      /[-*]\\s*(?:insight|finding|observation|recommendation):\\s*(.+)/gi,\n      /##\\s*(?:insight|finding|observation|recommendation):\\s*(.+)/gi,\n      /(?:key\\s+)?(?:insight|finding|observation|recommendation):\\s*(.+)/gi,\n    ];\n\n    for (const pattern of patterns) {\n      const matches = output.matchAll(pattern);\n      for (const match of matches) {\n        if (match[1]) {\n          insights.push(match[1].trim());\n        }\n      }\n    }\n\n    // Deduplicate\n    return [...new Set(insights)];\n  }\n\n  /**\n   * Format output for documentation\n   */\n  private formatOutput(agent: AgentConfig, output: string): string {\n    const timestamp = new Date().toISOString();\n\n    return `---\ntitle: \"${agent.name} Analysis\"\ntype: analysis\ngenerator: deep-analyzer\nagent: ${agent.type}\ncreated: ${timestamp}\n---\n\n# ${agent.name} Analysis\n\n> Generated by DeepAnalyzer using claude-flow\n\n## Overview\n\n${agent.task}\n\n## Analysis\n\n${output}\n\n---\n\n*Generated on ${new Date().toLocaleString()}*\n`;\n  }\n}\n\n/**\n * Create a deep analyzer instance\n */\nexport function createDeepAnalyzer(options: DeepAnalyzerOptions): DeepAnalyzer {\n  return new DeepAnalyzer(options);\n}\n\n/**\n * Run deep analysis on a project\n */\nexport async function analyzeDeep(\n  projectRoot: string,\n  docsPath?: string\n): Promise<DeepAnalysisResult> {\n  const analyzer = new DeepAnalyzer({ projectRoot, docsPath });\n  return analyzer.analyze();\n}\n"],"names":["resolve"],"mappings":"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"}

package/dist/cultivation/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cultivation System - Module Exports
+ *
+ * Provides seed generation, dependency analysis, and primitive node creation
+ * from codebase analysis.
+ *
+ * @module cultivation
+ */
+export type { VaultContext, Ecosystem, DependencyType, ServiceType, DependencyInfo, ServiceInfo, SeedAnalysis, DocumentMetadata, GeneratedDocument, CultivationReport, CultivationOptions, GapAnalysis, InitPrimitivesResult } from './types.js';
+export { SeedGenerator, analyzeSeed, initPrimitives } from './seed-generator.js';
+export { DeepAnalyzer, createDeepAnalyzer, analyzeDeep, } from './deep-analyzer.js';
+export type { DeepAnalyzerOptions, AgentResult, DeepAnalysisResult, } from './deep-analyzer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cultivation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cultivation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EACV,YAAY,EACZ,SAAS,EACT,cAAc,EACd,WAAW,EACX,cAAc,EACd,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,aAAa,EACb,WAAW,EACX,cAAc,EACf,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,WAAW,GACZ,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,mBAAmB,EACnB,WAAW,EACX,kBAAkB,GACnB,MAAM,oBAAoB,CAAC"}

package/dist/cultivation/seed-generator.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Seed Generator - Bootstrap knowledge graph with primitive nodes from codebase analysis
+ *
+ * Analyzes:
+ * - package.json (Node.js dependencies)
+ * - composer.json (PHP dependencies)
+ * - requirements.txt / pyproject.toml (Python)
+ * - Cargo.toml (Rust)
+ * - go.mod (Go)
+ * - pom.xml / build.gradle (Java)
+ * - Existing vault documents
+ * - Service configurations
+ * - Deployment manifests
+ *
+ * @module cultivation/seed-generator
+ */
+import type { VaultContext, SeedAnalysis, GeneratedDocument, CultivationOptions, InitPrimitivesResult } from './types.js';
+/**
+ * SeedGenerator class for analyzing codebases and generating primitive nodes
+ */
+export declare class SeedGenerator {
+    private vaultContext;
+    private projectRoot;
+    private startTime;
+    private filesScanned;
+    constructor(vaultContext: VaultContext, projectRoot: string);
+    /**
+     * Create a SeedGenerator from project paths
+     */
+    static create(projectRoot: string, docsPath: string): Promise<SeedGenerator>;
+    /**
+     * Collect all markdown files in vault
+     */
+    private static collectVaultFiles;
+    /**
+     * Analyze entire codebase and generate seed data
+     */
+    analyze(): Promise<SeedAnalysis>;
+    /**
+     * Generate primitive nodes from seed analysis
+     */
+    generatePrimitives(analysis: SeedAnalysis): Promise<GeneratedDocument[]>;
+    /**
+     * Write generated documents to disk
+     */
+    writePrimitives(documents: GeneratedDocument[]): Promise<InitPrimitivesResult>;
+    /**
+     * Full init-primitives workflow
+     */
+    initPrimitives(options?: CultivationOptions): Promise<InitPrimitivesResult>;
+    private analyzeDependencies;
+    private analyzePackageJson;
+    private analyzePython;
+    private analyzeComposer;
+    private analyzeCargo;
+    private analyzeGoMod;
+    private analyzeJava;
+    private createDependencyInfo;
+    private analyzeVaultDocuments;
+    private analyzeServices;
+    private extractPorts;
+    private analyzeDeployments;
+    private classifyDependencies;
+    private inferDependencyType;
+    private inferCategory;
+    private getDocumentationLinks;
+    private getRepositoryUrl;
+    private inferServiceType;
+    private shouldGenerateNode;
+    private generateFrameworkNode;
+    private generateDependencyNode;
+    private generateServiceNode;
+    private generateLanguageNode;
+    private buildFrameworkContent;
+    private buildDependencyContent;
+    private buildServiceContent;
+    private buildLanguageContent;
+    private findRelatedTechnologies;
+    private formatTitle;
+    private slugify;
+    private getLinkText;
+    private getLanguageDocUrl;
+}
+/**
+ * Create and run a seed analysis
+ */
+export declare function analyzeSeed(projectRoot: string, docsPath: string): Promise<SeedAnalysis>;
+/**
+ * Initialize primitives from codebase analysis
+ */
+export declare function initPrimitives(projectRoot: string, docsPath: string, options?: CultivationOptions): Promise<InitPrimitivesResult>;
+//# sourceMappingURL=seed-generator.d.ts.map

package/dist/cultivation/seed-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-generator.d.ts","sourceRoot":"","sources":["../../src/cultivation/seed-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,KAAK,EACV,YAAY,EAGZ,YAAY,EACZ,iBAAiB,EAKjB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAIpB;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,YAAY,CAAa;gBAErB,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM;IAK3D;;OAEG;WACU,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAgClF;;OAEG;mBACkB,iBAAiB;IAuBtC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC;IAuDtC;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;IA2C9E;;OAEG;IACG,eAAe,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA2DpF;;OAEG;IACG,cAAc,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,oBAAoB,CAAC;YAwBnE,mBAAmB;YASnB,kBAAkB;YAmElB,aAAa;YAuDb,eAAe;YAyBf,YAAY;YA0BZ,YAAY;YAoCZ,WAAW;IAqCzB,OAAO,CAAC,oBAAoB;YAmBd,qBAAqB;YA8BrB,eAAe;IAiF7B,OAAO,CAAC,YAAY;YAcN,kBAAkB;IA4BhC,OAAO,CAAC,oBAAoB;IAsB5B,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,aAAa;IAkDrB,OAAO,CAAC,qBAAqB;IA8B7B,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,kBAAkB;IAqB1B,OAAO,CAAC,qBAAqB;IA6B7B,OAAO,CAAC,sBAAsB;IA6B9B,OAAO,CAAC,mBAAmB;IA0B3B,OAAO,CAAC,oBAAoB;IA4B5B,OAAO,CAAC,qBAAqB;IA4C7B,OAAO,CAAC,sBAAsB;IAgC9B,OAAO,CAAC,mBAAmB;IAoC3B,OAAO,CAAC,oBAAoB;IA0C5B,OAAO,CAAC,uBAAuB;IAa/B,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,iBAAiB;CAc1B;AAMD;;GAEG;AACH,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAG9F;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,oBAAoB,CAAC,CAG/B"}