chainlesschain 0.37.10 → 0.37.12

package/src/lib/cowork/ab-comparator-cli.js

@@ -0,0 +1,180 @@
+/**
+ * A/B Comparator for CLI
+ *
+ * Generates N solution variants for a prompt using different agent configurations,
+ * then scores and ranks them against specified criteria.
+ */
+
+import { createChatFn } from "../cowork-adapter.js";
+
+const DEFAULT_CRITERIA = ["quality", "performance", "readability"];
+
+const VARIANT_PROFILES = [
+  {
+    name: "conservative",
+    system:
+      "You are a conservative software engineer who favors proven patterns, stability, and minimal dependencies. Prefer simple, well-tested approaches over cutting-edge solutions.",
+  },
+  {
+    name: "innovative",
+    system:
+      "You are an innovative software engineer who favors modern patterns, new APIs, and elegant abstractions. Prioritize developer experience and future-proofing.",
+  },
+  {
+    name: "pragmatic",
+    system:
+      "You are a pragmatic software engineer who balances simplicity with capability. Choose the approach that ships fastest while maintaining acceptable quality.",
+  },
+  {
+    name: "performance-focused",
+    system:
+      "You are a performance-oriented engineer. Optimize for speed, memory efficiency, and minimal overhead. Accept complexity if it yields measurable performance gains.",
+  },
+];
+
+/**
+ * Generate and compare N solution variants
+ *
+ * @param {object} params
+ * @param {string} params.prompt - The task/problem description
+ * @param {number} [params.variants=3] - Number of variants to generate
+ * @param {string[]} [params.criteria] - Scoring criteria
+ * @param {object} [params.llmOptions] - LLM provider options
+ * @returns {Promise<object>} Comparison result with ranked variants
+ */
+export async function compare({
+  prompt,
+  variants = 3,
+  criteria = DEFAULT_CRITERIA,
+  llmOptions = {},
+}) {
+  const chat = createChatFn(llmOptions);
+  const numVariants = Math.min(variants, VARIANT_PROFILES.length);
+  const profiles = VARIANT_PROFILES.slice(0, numVariants);
+  const generatedVariants = [];
+
+  // Phase 1: Generate variants
+  for (const profile of profiles) {
+    const messages = [
+      { role: "system", content: profile.system },
+      {
+        role: "user",
+        content: `Provide a solution for the following task. Include code if applicable.\n\nTask: ${prompt}\n\nProvide your solution with:\n1. Approach summary (1-2 sentences)\n2. Implementation (code or detailed steps)\n3. Trade-offs (pros and cons of this approach)`,
+      },
+    ];
+
+    try {
+      const response = await chat(messages, { maxTokens: 2000 });
+      generatedVariants.push({
+        name: profile.name,
+        profile: profile.system,
+        solution: response,
+      });
+    } catch (err) {
+      generatedVariants.push({
+        name: profile.name,
+        profile: profile.system,
+        solution: `Error generating variant: ${err.message}`,
+      });
+    }
+  }
+
+  // Phase 2: Score each variant against criteria
+  const scoringPrompt = `You are an impartial judge evaluating ${numVariants} solution variants against these criteria: ${criteria.join(", ")}.
+
+For each variant, assign a score from 1-10 for each criterion. Then provide an overall ranking.
+
+${generatedVariants
+  .map((v, i) => `### Variant ${i + 1}: ${v.name}\n${v.solution}`)
+  .join("\n\n---\n\n")}
+
+Respond in this exact format for each variant:
+SCORES:
+${generatedVariants.map((v, i) => `Variant ${i + 1} (${v.name}): ${criteria.map((c) => `${c}=X`).join(", ")}`).join("\n")}
+
+RANKING: (best to worst, comma-separated variant names)
+WINNER: (name of the best variant)
+REASON: (1-2 sentence justification)`;
+
+  let scores = [];
+  let ranking = [];
+  let winner = "";
+  let reason = "";
+
+  try {
+    const judgement = await chat(
+      [
+        {
+          role: "system",
+          content:
+            "You are an impartial technical evaluator. Score solutions objectively based on the given criteria.",
+        },
+        { role: "user", content: scoringPrompt },
+      ],
+      { maxTokens: 1500 },
+    );
+
+    // Parse scores
+    scores = parseScores(judgement, generatedVariants, criteria);
+    ranking = parseRanking(judgement, generatedVariants);
+    winner = parseWinner(judgement) || generatedVariants[0]?.name || "unknown";
+    reason = parseReason(judgement) || "See detailed scores above.";
+  } catch (err) {
+    reason = `Scoring error: ${err.message}`;
+  }
+
+  return {
+    prompt,
+    criteria,
+    variants: generatedVariants.map((v, i) => ({
+      ...v,
+      scores: scores[i] || {},
+      totalScore: scores[i]
+        ? Object.values(scores[i]).reduce((a, b) => a + b, 0)
+        : 0,
+    })),
+    ranking,
+    winner,
+    reason,
+  };
+}
+
+function parseScores(text, variants, criteria) {
+  const scores = [];
+  for (let i = 0; i < variants.length; i++) {
+    const variantScores = {};
+    for (const c of criteria) {
+      const pattern = new RegExp(
+        `variant\\s*${i + 1}[^\\n]*${c}\\s*=\\s*(\\d+)`,
+        "i",
+      );
+      const match = text.match(pattern);
+      variantScores[c] = match ? parseInt(match[1], 10) : 5;
+    }
+    scores.push(variantScores);
+  }
+  return scores;
+}
+
+function parseRanking(text, variants) {
+  const match = text.match(/RANKING:\s*(.+)/i);
+  if (match) {
+    return match[1]
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+  }
+  return variants.map((v) => v.name);
+}
+
+function parseWinner(text) {
+  const match = text.match(/WINNER:\s*(.+)/i);
+  return match ? match[1].trim() : null;
+}
+
+function parseReason(text) {
+  const match = text.match(/REASON:\s*(.+)/i);
+  return match ? match[1].trim() : null;
+}
+
+export { DEFAULT_CRITERIA, VARIANT_PROFILES };

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;
+}