chainlesschain 0.37.10 → 0.37.12

package/src/commands/bi.js

@@ -0,0 +1,240 @@
+/**
+ * BI commands
+ * chainlesschain bi query|dashboard|report|schedule|anomaly|predict|templates
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureBITables,
+  nlQuery,
+  createDashboard,
+  generateReport,
+  scheduleReport,
+  detectAnomaly,
+  predictTrend,
+  listTemplates,
+} from "../lib/bi-engine.js";
+
+export function registerBiCommand(program) {
+  const bi = program
+    .command("bi")
+    .description(
+      "Business intelligence — queries, dashboards, reports, analytics",
+    );
+
+  // bi query
+  bi.command("query <question>")
+    .description("Natural-language query (NL→SQL)")
+    .option("--json", "Output as JSON")
+    .action(async (question, options) => {
+      try {
+        const result = nlQuery(question);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success("Query translated");
+          logger.log(
+            `  ${chalk.bold("SQL:")}    ${chalk.cyan(result.generatedSQL)}`,
+          );
+          logger.log(`  ${chalk.bold("Rows:")}   ${result.rowCount}`);
+          logger.log(`  ${chalk.bold("Visual:")} ${result.visualization.type}`);
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // bi dashboard
+  bi.command("dashboard <name>")
+    .description("Create a dashboard")
+    .option("--widgets <json>", "Widgets as JSON array")
+    .option("--layout <json>", "Layout as JSON")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureBITables(db);
+
+        const widgets = options.widgets ? JSON.parse(options.widgets) : [];
+        const layout = options.layout ? JSON.parse(options.layout) : undefined;
+        const dashboard = createDashboard(db, name, widgets, layout);
+
+        if (options.json) {
+          console.log(JSON.stringify(dashboard, null, 2));
+        } else {
+          logger.success(`Dashboard created: ${chalk.cyan(name)}`);
+          logger.log(`  ${chalk.bold("ID:")}      ${chalk.cyan(dashboard.id)}`);
+          logger.log(`  ${chalk.bold("Widgets:")} ${dashboard.widgets.length}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // bi report
+  bi.command("report <name>")
+    .description("Generate a report")
+    .option("--format <pdf|excel>", "Report format", "pdf")
+    .option("--sections <csv>", "Comma-separated section names")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureBITables(db);
+
+        const sections = options.sections
+          ? options.sections.split(",").map((s) => s.trim())
+          : undefined;
+        const report = generateReport(db, name, {
+          format: options.format,
+          sections,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(report, null, 2));
+        } else {
+          logger.success(`Report generated: ${chalk.cyan(name)}`);
+          logger.log(`  ${chalk.bold("ID:")}       ${chalk.cyan(report.id)}`);
+          logger.log(`  ${chalk.bold("Format:")}   ${report.format}`);
+          logger.log(`  ${chalk.bold("Sections:")} ${report.sections.length}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // bi schedule
+  bi.command("schedule <report-id> <cron>")
+    .description("Schedule a report for recurring generation")
+    .option("--recipients <csv>", "Comma-separated recipient emails")
+    .action(async (reportId, cron, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureBITables(db);
+
+        const recipients = options.recipients
+          ? options.recipients.split(",").map((s) => s.trim())
+          : [];
+        const schedule = scheduleReport(db, reportId, cron, recipients);
+        logger.success("Report scheduled");
+        logger.log(`  ${chalk.bold("ID:")}         ${chalk.cyan(schedule.id)}`);
+        logger.log(`  ${chalk.bold("Cron:")}       ${schedule.cron}`);
+        logger.log(
+          `  ${chalk.bold("Recipients:")} ${schedule.recipients.length}`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // bi anomaly
+  bi.command("anomaly")
+    .description("Detect anomalies in data using Z-score")
+    .option("--data <json>", "Data as JSON array of numbers")
+    .option("--threshold <n>", "Z-score threshold", "2")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const data = options.data ? JSON.parse(options.data) : [];
+        const result = detectAnomaly(data, {
+          threshold: parseFloat(options.threshold),
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Mean:")}      ${result.mean.toFixed(2)}`);
+          logger.log(`  ${chalk.bold("Std Dev:")}   ${result.std.toFixed(2)}`);
+          logger.log(`  ${chalk.bold("Threshold:")} ${result.threshold}`);
+          logger.log(
+            `  ${chalk.bold("Anomalies:")} ${result.anomalies.length}`,
+          );
+          for (const a of result.anomalies) {
+            logger.log(
+              `    [${a.index}] value=${a.value} z=${a.zScore.toFixed(2)}`,
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // bi predict
+  bi.command("predict")
+    .description("Predict trend using linear regression")
+    .option("--data <json>", "Data as JSON array of numbers")
+    .option("--periods <n>", "Number of periods to predict", "3")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const data = options.data ? JSON.parse(options.data) : [];
+        const result = predictTrend(data, parseInt(options.periods));
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.bold("Trend:")}       ${chalk.cyan(result.trend)}`,
+          );
+          logger.log(`  ${chalk.bold("Slope:")}       ${result.slope}`);
+          logger.log(
+            `  ${chalk.bold("Predictions:")} ${result.predictions.join(", ")}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // bi templates
+  bi.command("templates")
+    .description("List available BI templates")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const templates = listTemplates();
+        if (options.json) {
+          console.log(JSON.stringify(templates, null, 2));
+        } else {
+          for (const t of templates) {
+            logger.log(
+              `  ${chalk.cyan(t.id)} ${chalk.bold(t.name)} — ${t.description}`,
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/cowork.js

@@ -0,0 +1,317 @@
+/**
+ * Multi-agent collaboration commands
+ * chainlesschain cowork debate|compare|analyze|status
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import path from "path";
+import { logger } from "../lib/logger.js";
+
+export function registerCoworkCommand(program) {
+  const cowork = program
+    .command("cowork")
+    .description(
+      "Multi-agent collaboration (debate review, A/B comparison, analysis)",
+    );
+
+  // cowork debate — multi-perspective code review
+  cowork
+    .command("debate")
+    .description("Multi-agent debate review of a file or topic")
+    .argument("<file-or-topic>", "File path to review, or a topic/question")
+    .option(
+      "--perspectives <list>",
+      "Comma-separated perspectives (performance,security,maintainability,correctness,architecture)",
+      "performance,security,maintainability",
+    )
+    .option("--provider <name>", "LLM provider to use")
+    .option("--model <name>", "LLM model to use")
+    .option("--json", "Output as JSON")
+    .action(async (target, options) => {
+      const { startDebate, DEFAULT_PERSPECTIVES } =
+        await import("../lib/cowork/debate-review-cli.js");
+
+      const perspectives = options.perspectives
+        .split(",")
+        .map((p) => p.trim())
+        .filter(Boolean);
+
+      // Read file content if target is a file path
+      let code = target;
+      let targetLabel = target;
+      const resolved = path.resolve(target);
+      if (fs.existsSync(resolved)) {
+        try {
+          code = fs.readFileSync(resolved, "utf-8");
+          targetLabel = resolved;
+          if (code.length > 15000) {
+            code = code.substring(0, 15000) + "\n... (truncated)";
+          }
+        } catch (err) {
+          logger.error(`Cannot read file: ${err.message}`);
+          process.exit(1);
+        }
+      }
+
+      const spinner = ora(
+        `Running debate review with ${perspectives.length} perspectives...`,
+      ).start();
+
+      try {
+        const llmOptions = {};
+        if (options.provider) llmOptions.provider = options.provider;
+        if (options.model) llmOptions.model = options.model;
+
+        const result = await startDebate({
+          target: targetLabel,
+          code,
+          perspectives,
+          llmOptions,
+        });
+        spinner.stop();
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        // Display results
+        logger.log(chalk.bold(`\nDebate Review: ${targetLabel}\n`));
+
+        for (const review of result.reviews) {
+          const verdictColor =
+            review.verdict === "APPROVE"
+              ? chalk.green
+              : review.verdict === "REJECT"
+                ? chalk.red
+                : chalk.yellow;
+          logger.log(
+            chalk.bold(`  ${review.role}: `) + verdictColor(review.verdict),
+          );
+          // Show first few lines of the review
+          const lines = review.review.split("\n").slice(0, 8);
+          for (const line of lines) {
+            logger.log(chalk.gray(`    ${line}`));
+          }
+          if (review.review.split("\n").length > 8) {
+            logger.log(chalk.gray("    ..."));
+          }
+          logger.log("");
+        }
+
+        logger.log(chalk.bold("Final Verdict"));
+        const verdictColor =
+          result.verdict === "APPROVE"
+            ? chalk.green
+            : result.verdict === "REJECT"
+              ? chalk.red
+              : chalk.yellow;
+        logger.log(`  Verdict:    ${verdictColor(result.verdict)}`);
+        logger.log(`  Consensus:  ${result.consensusScore}%`);
+        logger.log("");
+
+        // Show moderator summary
+        const summaryLines = result.summary.split("\n").slice(0, 15);
+        for (const line of summaryLines) {
+          logger.log(chalk.gray(`  ${line}`));
+        }
+        logger.log("");
+      } catch (err) {
+        spinner.fail(`Debate review failed: ${err.message}`);
+        if (program.opts().verbose) console.error(err.stack);
+        process.exit(1);
+      }
+    });
+
+  // cowork compare — A/B solution comparison
+  cowork
+    .command("compare")
+    .description("Generate and compare multiple solution variants")
+    .argument("<prompt>", "Task or problem description")
+    .option("--variants <n>", "Number of variants to generate (max 4)", "3")
+    .option(
+      "--criteria <list>",
+      "Comma-separated evaluation criteria",
+      "quality,performance,readability",
+    )
+    .option("--provider <name>", "LLM provider to use")
+    .option("--model <name>", "LLM model to use")
+    .option("--json", "Output as JSON")
+    .action(async (prompt, options) => {
+      const { compare } = await import("../lib/cowork/ab-comparator-cli.js");
+
+      const variants = parseInt(options.variants, 10) || 3;
+      const criteria = options.criteria
+        .split(",")
+        .map((c) => c.trim())
+        .filter(Boolean);
+
+      const spinner = ora(
+        `Generating ${variants} solution variants...`,
+      ).start();
+
+      try {
+        const llmOptions = {};
+        if (options.provider) llmOptions.provider = options.provider;
+        if (options.model) llmOptions.model = options.model;
+
+        const result = await compare({
+          prompt,
+          variants,
+          criteria,
+          llmOptions,
+        });
+        spinner.stop();
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        logger.log(chalk.bold(`\nA/B Comparison: ${prompt}\n`));
+        logger.log(chalk.gray(`Criteria: ${criteria.join(", ")}\n`));
+
+        for (const v of result.variants) {
+          logger.log(
+            chalk.bold(`  Variant: ${chalk.cyan(v.name)}`) +
+              chalk.gray(` (total: ${v.totalScore})`),
+          );
+
+          // Show scores
+          if (v.scores && Object.keys(v.scores).length > 0) {
+            const scoreStr = Object.entries(v.scores)
+              .map(([k, val]) => `${k}=${val}`)
+              .join(", ");
+            logger.log(chalk.gray(`    Scores: ${scoreStr}`));
+          }
+
+          // Show first lines of solution
+          const lines = v.solution.split("\n").slice(0, 6);
+          for (const line of lines) {
+            logger.log(chalk.gray(`    ${line}`));
+          }
+          if (v.solution.split("\n").length > 6) {
+            logger.log(chalk.gray("    ..."));
+          }
+          logger.log("");
+        }
+
+        logger.log(chalk.bold("Result"));
+        logger.log(`  Winner:  ${chalk.green(result.winner)}`);
+        logger.log(`  Reason:  ${chalk.gray(result.reason)}`);
+        if (result.ranking.length > 0) {
+          logger.log(
+            `  Ranking: ${result.ranking.map((r, i) => (i === 0 ? chalk.green(r) : chalk.gray(r))).join(" > ")}`,
+          );
+        }
+        logger.log("");
+      } catch (err) {
+        spinner.fail(`Comparison failed: ${err.message}`);
+        if (program.opts().verbose) console.error(err.stack);
+        process.exit(1);
+      }
+    });
+
+  // cowork analyze — code analysis (Phase 4B placeholder, delegates to knowledge modules)
+  cowork
+    .command("analyze")
+    .description("Analyze code structure, style, or knowledge graph")
+    .argument("<path>", "File or directory to analyze")
+    .option(
+      "--type <type>",
+      "Analysis type (style, knowledge-graph, decisions)",
+      "style",
+    )
+    .option("--provider <name>", "LLM provider to use")
+    .option("--model <name>", "LLM model to use")
+    .option("--json", "Output as JSON")
+    .action(async (targetPath, options) => {
+      const resolved = path.resolve(targetPath);
+      if (!fs.existsSync(resolved)) {
+        logger.error(`Path not found: ${resolved}`);
+        process.exit(1);
+      }
+
+      const spinner = ora(`Analyzing (${options.type})...`).start();
+
+      try {
+        let result;
+
+        if (options.type === "style") {
+          const { analyzeProjectStyle } =
+            await import("../lib/cowork/project-style-analyzer-cli.js");
+          const llmOptions = {};
+          if (options.provider) llmOptions.provider = options.provider;
+          if (options.model) llmOptions.model = options.model;
+          result = await analyzeProjectStyle({
+            targetPath: resolved,
+            llmOptions,
+          });
+        } else if (options.type === "knowledge-graph") {
+          const { buildKnowledgeGraph } =
+            await import("../lib/cowork/code-knowledge-graph-cli.js");
+          result = await buildKnowledgeGraph({ targetPath: resolved });
+        } else if (options.type === "decisions") {
+          const { extractDecisions } =
+            await import("../lib/cowork/decision-kb-cli.js");
+          const llmOptions = {};
+          if (options.provider) llmOptions.provider = options.provider;
+          if (options.model) llmOptions.model = options.model;
+          result = await extractDecisions({
+            targetPath: resolved,
+            llmOptions,
+          });
+        } else {
+          spinner.fail(`Unknown analysis type: ${options.type}`);
+          process.exit(1);
+        }
+
+        spinner.stop();
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(
+            chalk.bold(`\nAnalysis (${options.type}): ${targetPath}\n`),
+          );
+          if (result.summary) {
+            logger.log(result.summary);
+          } else {
+            console.log(JSON.stringify(result, null, 2));
+          }
+          logger.log("");
+        }
+      } catch (err) {
+        spinner.fail(`Analysis failed: ${err.message}`);
+        if (program.opts().verbose) console.error(err.stack);
+        process.exit(1);
+      }
+    });
+
+  // cowork status — show collaboration state
+  cowork
+    .command("status")
+    .description("Show cowork collaboration status")
+    .action(async () => {
+      logger.log(chalk.bold("\nCowork Status\n"));
+      logger.log(`  Available commands:`);
+      logger.log(
+        `    ${chalk.cyan("cowork debate <file>")}     Multi-perspective code review`,
+      );
+      logger.log(
+        `    ${chalk.cyan("cowork compare <prompt>")}  A/B solution comparison`,
+      );
+      logger.log(
+        `    ${chalk.cyan("cowork analyze <path>")}    Code analysis (style/knowledge-graph/decisions)`,
+      );
+      logger.log("");
+      logger.log(
+        chalk.gray(
+          "  All commands use the configured LLM provider. Override with --provider/--model.",
+        ),
+      );
+      logger.log("");
+    });
+}