chainlesschain 0.37.9 → 0.37.11

package/src/lib/cowork/code-knowledge-graph-cli.js

@@ -0,0 +1,232 @@
+/**
+ * Code Knowledge Graph for CLI
+ *
+ * Builds a lightweight entity-relationship graph from source code:
+ *   - Files, classes, functions, imports, exports
+ *   - Dependency relationships
+ */
+
+import fs from "fs";
+import path from "path";
+
+const CODE_EXTENSIONS = new Set([
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".vue",
+  ".py",
+  ".java",
+  ".go",
+  ".rs",
+  ".rb",
+  ".kt",
+  ".swift",
+]);
+
+/**
+ * Build a knowledge graph from a file or directory
+ *
+ * @param {object} params
+ * @param {string} params.targetPath - File or directory to analyze
+ * @param {number} [params.maxFiles=50] - Max files to process
+ * @returns {Promise<object>} Knowledge graph
+ */
+export async function buildKnowledgeGraph({ targetPath, maxFiles = 50 }) {
+  const entities = [];
+  const relationships = [];
+
+  const stat = fs.statSync(targetPath);
+  const files = stat.isDirectory()
+    ? collectFiles(targetPath, maxFiles)
+    : [targetPath];
+
+  for (const filePath of files) {
+    const ext = path.extname(filePath);
+    if (!CODE_EXTENSIONS.has(ext)) continue;
+
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const relativePath = path.relative(process.cwd(), filePath);
+
+      entities.push({
+        type: "file",
+        name: relativePath,
+        language: ext.slice(1),
+        lines: content.split("\n").length,
+      });
+
+      // Extract imports
+      const imports = extractImports(content, ext);
+      for (const imp of imports) {
+        relationships.push({
+          from: relativePath,
+          to: imp,
+          type: "imports",
+        });
+      }
+
+      // Extract exports / public APIs
+      const exports = extractExports(content, ext);
+      for (const exp of exports) {
+        entities.push({
+          type: "export",
+          name: exp.name,
+          kind: exp.kind,
+          file: relativePath,
+        });
+      }
+
+      // Extract classes/functions
+      const definitions = extractDefinitions(content, ext);
+      for (const def of definitions) {
+        entities.push({
+          type: def.kind,
+          name: def.name,
+          file: relativePath,
+          line: def.line,
+        });
+      }
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  // Build summary
+  const fileCount = entities.filter((e) => e.type === "file").length;
+  const exportCount = entities.filter((e) => e.type === "export").length;
+  const defCount = entities.filter(
+    (e) => e.type === "class" || e.type === "function",
+  ).length;
+
+  const summary = [
+    `Code Knowledge Graph for: ${targetPath}`,
+    `  Files analyzed: ${fileCount}`,
+    `  Entities: ${entities.length} (${defCount} definitions, ${exportCount} exports)`,
+    `  Relationships: ${relationships.length}`,
+    "",
+    "Top imports:",
+    ...getTopImports(relationships).map((r) => `  ${r.to} (${r.count} refs)`),
+  ].join("\n");
+
+  return {
+    entities,
+    relationships,
+    stats: {
+      fileCount,
+      exportCount,
+      defCount,
+      relationshipCount: relationships.length,
+    },
+    summary,
+  };
+}
+
+function collectFiles(dir, maxFiles) {
+  const files = [];
+  const queue = [dir];
+
+  while (queue.length > 0 && files.length < maxFiles) {
+    const current = queue.shift();
+    try {
+      const entries = fs.readdirSync(current, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+          continue;
+        const fullPath = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+          queue.push(fullPath);
+        } else if (CODE_EXTENSIONS.has(path.extname(entry.name))) {
+          files.push(fullPath);
+          if (files.length >= maxFiles) break;
+        }
+      }
+    } catch {
+      // Skip unreadable dirs
+    }
+  }
+
+  return files;
+}
+
+function extractImports(content, ext) {
+  const imports = [];
+
+  // ES6 imports
+  const esImportRe = /import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = esImportRe.exec(content))) {
+    imports.push(match[1]);
+  }
+
+  // CommonJS require
+  const cjsRe = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = cjsRe.exec(content))) {
+    imports.push(match[1]);
+  }
+
+  // Python imports
+  if (ext === ".py") {
+    const pyRe = /(?:from|import)\s+([\w.]+)/g;
+    while ((match = pyRe.exec(content))) {
+      imports.push(match[1]);
+    }
+  }
+
+  return [...new Set(imports)];
+}
+
+function extractExports(content, ext) {
+  const exports = [];
+
+  // ES6 exports
+  const esExportRe =
+    /export\s+(?:default\s+)?(?:(?:async\s+)?function|class|const|let|var)\s+(\w+)/g;
+  let match;
+  while ((match = esExportRe.exec(content))) {
+    exports.push({ name: match[1], kind: "named" });
+  }
+
+  // module.exports
+  if (/module\.exports\s*=/.test(content)) {
+    exports.push({ name: "default", kind: "cjs" });
+  }
+
+  return exports;
+}
+
+function extractDefinitions(content, ext) {
+  const defs = [];
+  const lines = content.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Class definitions
+    const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+    if (classMatch) {
+      defs.push({ kind: "class", name: classMatch[1], line: i + 1 });
+    }
+
+    // Function definitions
+    const funcMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+    if (funcMatch) {
+      defs.push({ kind: "function", name: funcMatch[1], line: i + 1 });
+    }
+  }
+
+  return defs;
+}
+
+function getTopImports(relationships) {
+  const counts = {};
+  for (const r of relationships) {
+    if (r.type === "imports") {
+      counts[r.to] = (counts[r.to] || 0) + 1;
+    }
+  }
+  return Object.entries(counts)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([to, count]) => ({ to, count }));
+}

package/src/lib/cowork/debate-review-cli.js

@@ -0,0 +1,144 @@
+/**
+ * Multi-perspective debate review for CLI
+ *
+ * Spawns multiple reviewer agents (performance, security, maintainability, etc.)
+ * Each reviews independently via LLM, then a moderator synthesizes a verdict.
+ */
+
+import { createChatFn } from "../cowork-adapter.js";
+
+const DEFAULT_PERSPECTIVES = ["performance", "security", "maintainability"];
+
+const PERSPECTIVE_PROMPTS = {
+  performance: {
+    role: "Performance Reviewer",
+    system:
+      "You are a performance-focused code reviewer. Analyze code for time complexity, memory usage, unnecessary allocations, blocking operations, N+1 queries, and scalability issues. Be specific and cite line numbers when possible.",
+  },
+  security: {
+    role: "Security Reviewer",
+    system:
+      "You are a security-focused code reviewer. Analyze code for injection vulnerabilities, authentication/authorization issues, data exposure, insecure defaults, OWASP top 10, and supply chain risks. Be specific and cite line numbers when possible.",
+  },
+  maintainability: {
+    role: "Maintainability Reviewer",
+    system:
+      "You are a maintainability-focused code reviewer. Analyze code for readability, naming conventions, coupling, cohesion, DRY violations, missing error handling, test coverage gaps, and documentation needs. Be specific and cite line numbers when possible.",
+  },
+  correctness: {
+    role: "Correctness Reviewer",
+    system:
+      "You are a correctness-focused code reviewer. Analyze code for logic errors, off-by-one bugs, race conditions, null/undefined handling, edge cases, type mismatches, and incorrect assumptions. Be specific and cite line numbers when possible.",
+  },
+  architecture: {
+    role: "Architecture Reviewer",
+    system:
+      "You are an architecture-focused code reviewer. Analyze code for separation of concerns, dependency management, design pattern usage, extensibility, and alignment with established project patterns. Be specific.",
+  },
+};
+
+/**
+ * Run a multi-perspective debate review
+ *
+ * @param {object} params
+ * @param {string} params.target - Description of what's being reviewed
+ * @param {string} params.code - The code to review
+ * @param {string[]} [params.perspectives] - Perspectives to use
+ * @param {object} [params.llmOptions] - LLM provider options
+ * @returns {Promise<object>} Review result with verdict and reviews
+ */
+export async function startDebate({
+  target,
+  code,
+  perspectives = DEFAULT_PERSPECTIVES,
+  llmOptions = {},
+}) {
+  const chat = createChatFn(llmOptions);
+  const reviews = [];
+
+  // Phase 1: Independent reviews from each perspective
+  for (const perspective of perspectives) {
+    const config = PERSPECTIVE_PROMPTS[perspective] || {
+      role: `${perspective} Reviewer`,
+      system: `You are a ${perspective}-focused code reviewer. Provide specific, actionable feedback.`,
+    };
+
+    const messages = [
+      { role: "system", content: config.system },
+      {
+        role: "user",
+        content: `Review the following code/content.\n\nTarget: ${target}\n\n\`\`\`\n${code}\n\`\`\`\n\nProvide your review as a ${config.role}. Format your response as:\n\n## Issues Found\n- List each issue with severity (HIGH/MEDIUM/LOW)\n\n## Recommendations\n- List specific improvements\n\n## Verdict\nAPPROVE, NEEDS_WORK, or REJECT with a brief reason.`,
+      },
+    ];
+
+    try {
+      const response = await chat(messages, { maxTokens: 1500 });
+      const verdict = extractVerdict(response);
+      reviews.push({
+        perspective,
+        role: config.role,
+        review: response,
+        verdict,
+      });
+    } catch (err) {
+      reviews.push({
+        perspective,
+        role: config.role,
+        review: `Error: ${err.message}`,
+        verdict: "ERROR",
+      });
+    }
+  }
+
+  // Phase 2: Moderator synthesizes final verdict
+  const moderatorMessages = [
+    {
+      role: "system",
+      content:
+        "You are a senior engineering lead moderating a code review. Synthesize the perspectives below into a final verdict. Weight security and correctness issues higher than style concerns.",
+    },
+    {
+      role: "user",
+      content: `Multiple reviewers analyzed this code. Synthesize their findings into a final verdict.\n\nTarget: ${target}\n\n${reviews
+        .map((r) => `### ${r.role} (${r.verdict})\n${r.review}`)
+        .join(
+          "\n\n---\n\n",
+        )}\n\nProvide:\n1. Final Verdict: APPROVE / NEEDS_WORK / REJECT\n2. Consensus Score: 0-100 (how much the reviewers agree)\n3. Summary of key findings across all perspectives\n4. Priority action items (if any)`,
+    },
+  ];
+
+  let finalVerdict = "NEEDS_WORK";
+  let consensusScore = 50;
+  let summary = "";
+
+  try {
+    summary = await chat(moderatorMessages, { maxTokens: 1500 });
+    finalVerdict = extractVerdict(summary);
+    consensusScore = extractConsensusScore(summary);
+  } catch (err) {
+    summary = `Moderator error: ${err.message}`;
+  }
+
+  return {
+    target,
+    perspectives,
+    reviews,
+    verdict: finalVerdict,
+    consensusScore,
+    summary,
+  };
+}
+
+function extractVerdict(text) {
+  if (/\bREJECT\b/i.test(text)) return "REJECT";
+  if (/\bAPPROVE\b/i.test(text)) return "APPROVE";
+  return "NEEDS_WORK";
+}
+
+function extractConsensusScore(text) {
+  const match = text.match(/consensus\s*score[:\s]*(\d+)/i);
+  if (match) return parseInt(match[1], 10);
+  return 50;
+}
+
+export { DEFAULT_PERSPECTIVES, PERSPECTIVE_PROMPTS };

package/src/lib/cowork/decision-kb-cli.js

@@ -0,0 +1,153 @@
+/**
+ * Decision Knowledge Base for CLI
+ *
+ * Extracts architectural decisions from code and documentation using LLM analysis.
+ * Outputs structured ADR-like records.
+ */
+
+import fs from "fs";
+import path from "path";
+import { createChatFn } from "../cowork-adapter.js";
+
+/**
+ * Extract architectural decisions from a file or directory
+ *
+ * @param {object} params
+ * @param {string} params.targetPath - File or directory to analyze
+ * @param {object} [params.llmOptions] - LLM provider options
+ * @returns {Promise<object>} Extracted decisions
+ */
+export async function extractDecisions({ targetPath, llmOptions = {} }) {
+  const chat = createChatFn(llmOptions);
+  const stat = fs.statSync(targetPath);
+
+  let content;
+  if (stat.isDirectory()) {
+    // Read key files that typically contain decisions
+    const candidates = [
+      "CLAUDE.md",
+      "CLAUDE-decisions.md",
+      "README.md",
+      "ARCHITECTURE.md",
+      "ADR",
+      "docs/adr",
+      "docs/decisions",
+      "package.json",
+    ];
+    const parts = [];
+    for (const candidate of candidates) {
+      const fullPath = path.join(targetPath, candidate);
+      if (fs.existsSync(fullPath)) {
+        const stat2 = fs.statSync(fullPath);
+        if (stat2.isFile()) {
+          try {
+            const fileContent = fs.readFileSync(fullPath, "utf-8");
+            parts.push(
+              `--- ${candidate} ---\n${fileContent.substring(0, 5000)}`,
+            );
+          } catch {
+            // Skip
+          }
+        } else if (stat2.isDirectory()) {
+          // Read first few files in ADR directory
+          try {
+            const files = fs.readdirSync(fullPath).slice(0, 10);
+            for (const f of files) {
+              const fp = path.join(fullPath, f);
+              if (fs.statSync(fp).isFile()) {
+                const fc = fs.readFileSync(fp, "utf-8");
+                parts.push(
+                  `--- ${candidate}/${f} ---\n${fc.substring(0, 3000)}`,
+                );
+              }
+            }
+          } catch {
+            // Skip
+          }
+        }
+      }
+    }
+    content = parts.join("\n\n");
+  } else {
+    content = fs.readFileSync(targetPath, "utf-8");
+  }
+
+  if (!content || content.trim().length === 0) {
+    return {
+      decisions: [],
+      summary: "No relevant content found for decision extraction.",
+    };
+  }
+
+  // Truncate if too long
+  if (content.length > 20000) {
+    content = content.substring(0, 20000) + "\n... (truncated)";
+  }
+
+  const messages = [
+    {
+      role: "system",
+      content: `You are an experienced software architect. Extract architectural decisions from the provided content. For each decision, identify:
+1. Title — short name for the decision
+2. Status — (accepted, proposed, deprecated, superseded)
+3. Context — why was this decision needed?
+4. Decision — what was decided?
+5. Consequences — what are the trade-offs?
+
+Format each decision as:
+### Decision: <title>
+- **Status**: <status>
+- **Context**: <context>
+- **Decision**: <what was decided>
+- **Consequences**: <trade-offs>
+
+List all decisions you can find. If no explicit decisions are documented, infer them from technology choices, patterns, and configuration.`,
+    },
+    {
+      role: "user",
+      content: `Extract architectural decisions from this content:\n\n${content}`,
+    },
+  ];
+
+  try {
+    const response = await chat(messages, { maxTokens: 2000 });
+    const decisions = parseDecisions(response);
+
+    return {
+      decisions,
+      raw: response,
+      summary: `Found ${decisions.length} architectural decisions in ${targetPath}\n\n${decisions.map((d) => `  - ${d.title} (${d.status})`).join("\n")}`,
+    };
+  } catch (err) {
+    return {
+      decisions: [],
+      summary: `Decision extraction failed: ${err.message}`,
+    };
+  }
+}
+
+function parseDecisions(text) {
+  const decisions = [];
+  const sections = text.split(/###\s*Decision:\s*/i);
+
+  for (let i = 1; i < sections.length; i++) {
+    const section = sections[i];
+    const lines = section.split("\n");
+    const title = lines[0].trim();
+
+    const statusMatch = section.match(/\*\*Status\*\*:\s*(.+)/i);
+    const contextMatch = section.match(/\*\*Context\*\*:\s*(.+)/i);
+    const decisionMatch = section.match(/\*\*Decision\*\*:\s*(.+)/i);
+    const consequencesMatch = section.match(/\*\*Consequences?\*\*:\s*(.+)/i);
+
+    decisions.push({
+      title,
+      status: statusMatch ? statusMatch[1].trim() : "accepted",
+      context: contextMatch ? contextMatch[1].trim() : "",
+      decision: decisionMatch ? decisionMatch[1].trim() : "",
+      consequences: consequencesMatch ? consequencesMatch[1].trim() : "",
+    });
+  }
+
+  return decisions;
+}

package/src/lib/cowork/project-style-analyzer-cli.js

@@ -0,0 +1,168 @@
+/**
+ * Project Style Analyzer for CLI
+ *
+ * Analyzes coding style, conventions, and patterns in a codebase using LLM.
+ */
+
+import fs from "fs";
+import path from "path";
+import { createChatFn } from "../cowork-adapter.js";
+
+const CODE_EXTENSIONS = new Set([
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".vue",
+  ".py",
+  ".java",
+  ".go",
+  ".rs",
+  ".kt",
+]);
+
+/**
+ * Analyze project coding style and conventions
+ *
+ * @param {object} params
+ * @param {string} params.targetPath - File or directory to analyze
+ * @param {object} [params.llmOptions] - LLM provider options
+ * @returns {Promise<object>} Style analysis result
+ */
+export async function analyzeProjectStyle({ targetPath, llmOptions = {} }) {
+  const chat = createChatFn(llmOptions);
+  const stat = fs.statSync(targetPath);
+
+  // Collect sample files
+  const samples = [];
+  if (stat.isDirectory()) {
+    const files = collectSampleFiles(targetPath, 8);
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(file, "utf-8");
+        const relative = path.relative(process.cwd(), file);
+        samples.push({
+          path: relative,
+          content: content.substring(0, 3000),
+          ext: path.extname(file),
+        });
+      } catch {
+        // Skip
+      }
+    }
+  } else {
+    const content = fs.readFileSync(targetPath, "utf-8");
+    samples.push({
+      path: path.relative(process.cwd(), targetPath),
+      content: content.substring(0, 5000),
+      ext: path.extname(targetPath),
+    });
+  }
+
+  if (samples.length === 0) {
+    return { patterns: [], summary: "No code files found to analyze." };
+  }
+
+  // Check for config files
+  const configFiles = [];
+  const configCandidates = [
+    ".eslintrc.js",
+    ".eslintrc.json",
+    ".prettierrc",
+    "tsconfig.json",
+    "pyproject.toml",
+    ".editorconfig",
+    "biome.json",
+  ];
+  const baseDir = stat.isDirectory() ? targetPath : path.dirname(targetPath);
+  for (const cf of configCandidates) {
+    const cfPath = path.join(baseDir, cf);
+    if (fs.existsSync(cfPath)) {
+      try {
+        configFiles.push({
+          name: cf,
+          content: fs.readFileSync(cfPath, "utf-8").substring(0, 2000),
+        });
+      } catch {
+        // Skip
+      }
+    }
+  }
+
+  const codeContext = samples
+    .map((s) => `--- ${s.path} ---\n${s.content}`)
+    .join("\n\n");
+
+  const configContext =
+    configFiles.length > 0
+      ? `\n\nConfiguration files:\n${configFiles.map((c) => `--- ${c.name} ---\n${c.content}`).join("\n\n")}`
+      : "";
+
+  const messages = [
+    {
+      role: "system",
+      content: `You are a senior code reviewer analyzing project conventions. Identify:
+1. Naming conventions (variables, functions, files)
+2. Code organization patterns
+3. Import/export style
+4. Error handling patterns
+5. Comment/documentation style
+6. Testing patterns (if visible)
+7. Formatting preferences (indentation, quotes, semicolons)
+
+Be specific with examples from the code samples provided.`,
+    },
+    {
+      role: "user",
+      content: `Analyze the coding style and conventions in these ${samples.length} code samples:\n\n${codeContext}${configContext}\n\nProvide a structured analysis of the project's coding conventions and patterns.`,
+    },
+  ];
+
+  try {
+    const response = await chat(messages, { maxTokens: 2000 });
+
+    return {
+      samplesAnalyzed: samples.length,
+      configFilesFound: configFiles.map((c) => c.name),
+      analysis: response,
+      summary: `Style Analysis for: ${targetPath}\n  Samples: ${samples.length} files\n  Config: ${configFiles.map((c) => c.name).join(", ") || "none found"}\n\n${response}`,
+    };
+  } catch (err) {
+    return {
+      samplesAnalyzed: samples.length,
+      summary: `Style analysis failed: ${err.message}`,
+    };
+  }
+}
+
+function collectSampleFiles(dir, maxFiles) {
+  const files = [];
+  const queue = [dir];
+
+  while (queue.length > 0 && files.length < maxFiles) {
+    const current = queue.shift();
+    try {
+      const entries = fs.readdirSync(current, { withFileTypes: true });
+      for (const entry of entries) {
+        if (
+          entry.name.startsWith(".") ||
+          entry.name === "node_modules" ||
+          entry.name === "dist"
+        ) {
+          continue;
+        }
+        const fullPath = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+          queue.push(fullPath);
+        } else if (CODE_EXTENSIONS.has(path.extname(entry.name))) {
+          files.push(fullPath);
+          if (files.length >= maxFiles) break;
+        }
+      }
+    } catch {
+      // Skip
+    }
+  }
+
+  return files;
+}