chainlesschain 0.47.9 → 0.51.0

package/src/commands/mcp.js

@@ -9,7 +9,11 @@ import chalk from "chalk";
 import ora from "ora";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
-import { MCPClient, MCPServerConfig } from "../harness/mcp-client.js";
+import {
+  MCPClient,
+  MCPServerConfig,
+  inferTransport,
+} from "../harness/mcp-client.js";
 import {
   validateMcpServer,
   annotateMcpCompatibility,
@@ -111,9 +115,15 @@ export function registerMcpCommand(program) {
               ? chalk.green(" [ok]")
               : chalk.yellow(` [blocked: ${s._reason}]`);
             logger.log(`  ${chalk.cyan(s.name)}${auto}${flag}`);
-            logger.log(
-              `    ${chalk.gray("Command:")} ${s.command} ${s.args.join(" ")}`,
-            );
+            if (s.url) {
+              logger.log(
+                `    ${chalk.gray("URL:")} ${s.url} ${chalk.gray(`[${s.transport || s._transport || "http"}]`)}`,
+              );
+            } else {
+              logger.log(
+                `    ${chalk.gray("Command:")} ${s.command} ${s.args.join(" ")}`,
+              );
+            }
             logger.log(
               `    ${chalk.gray("Compatible:")} ${s._modeCompatibility.join(", ") || "(none)"}`,
             );
@@ -132,8 +142,20 @@ export function registerMcpCommand(program) {
     .command("add")
     .description("Add or update an MCP server configuration")
     .argument("<name>", "Server name")
-    .requiredOption("-c, --command <cmd>", "Server command to run")
+    .option("-c, --command <cmd>", "Server command to run (stdio transport)")
     .option("-a, --args <args>", "Command arguments (comma-separated)")
+    .option(
+      "-u, --url <url>",
+      "Server URL (http / https / ws / wss transports)",
+    )
+    .option(
+      "-t, --transport <kind>",
+      "Transport kind: stdio | http | https | sse | ws | wss",
+    )
+    .option(
+      "-H, --header <header...>",
+      "HTTP header to include on requests (KEY=VALUE, repeatable)",
+    )
     .option("--auto-connect", "Auto-connect on startup")
     .option(
       "--mode <mode>",
@@ -142,6 +164,17 @@ export function registerMcpCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (name, options) => {
       try {
+        if (!options.command && !options.url) {
+          logger.error(
+            "Provide either -c <command> (stdio) or -u <url> (http/ws).",
+          );
+          process.exit(1);
+        }
+        if (options.command && options.url) {
+          logger.error("Use either -c <command> or -u <url>, not both.");
+          process.exit(1);
+        }
+
         const ctx = await bootstrap({ verbose: program.opts().verbose });
         if (!ctx.db) {
           logger.error("Database not available");
@@ -154,9 +187,43 @@ export function registerMcpCommand(program) {
           ? options.args.split(",").map((a) => a.trim())
           : [];
 
+        // Parse -H KEY=VALUE into { headers }
+        const headers = {};
+        if (Array.isArray(options.header)) {
+          for (const raw of options.header) {
+            const eq = raw.indexOf("=");
+            if (eq <= 0) {
+              logger.warn(
+                `Ignored malformed --header "${raw}" (expected KEY=VALUE)`,
+              );
+              continue;
+            }
+            headers[raw.slice(0, eq).trim()] = raw.slice(eq + 1);
+          }
+        }
+
+        const transport =
+          options.transport ||
+          (options.url ? inferTransport({ url: options.url }) : "stdio");
+
+        if (options.url) {
+          try {
+            new URL(options.url);
+          } catch (_e) {
+            logger.error(`Invalid URL: ${options.url}`);
+            process.exit(1);
+          }
+        }
+
         const mode = resolveMode(options);
         const check = validateMcpServer(
-          { name, command: options.command, args },
+          {
+            name,
+            command: options.command,
+            args,
+            url: options.url,
+            transport,
+          },
           mode,
         );
         if (!check.allowed) {
@@ -166,25 +233,37 @@ export function registerMcpCommand(program) {
         }
 
         config.add(name, {
-          command: options.command,
+          command: options.command || null,
           args,
+          url: options.url || null,
+          transport,
+          env: {},
           autoConnect: !!options.autoConnect,
+          headers: Object.keys(headers).length > 0 ? headers : undefined,
         });
 
+        const payload = {
+          name,
+          command: options.command || null,
+          args,
+          url: options.url || null,
+          transport,
+          autoConnect: !!options.autoConnect,
+        };
+
         if (options.json) {
-          console.log(
-            JSON.stringify({
-              name,
-              command: options.command,
-              args,
-              autoConnect: !!options.autoConnect,
-            }),
-          );
+          console.log(JSON.stringify(payload));
         } else {
           logger.success(`MCP server "${chalk.cyan(name)}" configured`);
-          logger.log(
-            `  ${chalk.gray("Command:")} ${options.command} ${args.join(" ")}`,
-          );
+          if (options.url) {
+            logger.log(
+              `  ${chalk.gray("URL:")} ${options.url} ${chalk.gray(`[${transport}]`)}`,
+            );
+          } else {
+            logger.log(
+              `  ${chalk.gray("Command:")} ${options.command} ${args.join(" ")}`,
+            );
+          }
         }
 
         await shutdown();

package/src/commands/multimodal.js

@@ -0,0 +1,404 @@
+/**
+ * `cc multimodal` — CLI surface for Phase 27 多模态协作.
+ *
+ * Exposes 5-modality weighted fusion, doc parsing (txt/md/csv/json),
+ * context building with 4000-token cap, and 6 output formats.
+ */
+
+import fs from "fs";
+import { Command } from "commander";
+
+import {
+  MODALITIES,
+  MODALITY_WEIGHTS,
+  INPUT_FORMATS,
+  NATIVE_FORMATS,
+  OUTPUT_FORMATS,
+  SESSION_STATUS,
+  DEFAULT_MAX_TOKENS,
+  ensureMultimodalTables,
+  createSession,
+  getSession,
+  listSessions,
+  completeSession,
+  deleteSession,
+  addModality,
+  getSessionModalities,
+  fuse,
+  parseDocument,
+  getSupportedFormats,
+  buildContext,
+  getContext,
+  clearContext,
+  trimContext,
+  generateOutput,
+  getOutputFormats,
+  listArtifacts,
+  getMultimodalStats,
+} from "../lib/multimodal.js";
+
+function _dbFromCtx(cmd) {
+  const root = cmd?.parent?.parent ?? cmd?.parent;
+  return root?._db;
+}
+
+function _parseJson(raw) {
+  if (raw == null) return null;
+  try {
+    return JSON.parse(raw);
+  } catch (_e) {
+    return raw;
+  }
+}
+
+function _readData(opts) {
+  if (opts.file) return fs.readFileSync(opts.file, "utf-8");
+  if (opts.text != null) return opts.text;
+  if (opts.data != null) return _parseJson(opts.data);
+  return null;
+}
+
+export function registerMultimodalCommand(program) {
+  const mm = new Command("multimodal")
+    .alias("mm")
+    .description("Multimodal collaboration (Phase 27)")
+    .hook("preAction", (thisCmd) => {
+      const db = _dbFromCtx(thisCmd);
+      if (db) ensureMultimodalTables(db);
+    });
+
+  /* ── Catalogs ─────────────────────────────────────── */
+
+  mm.command("modalities")
+    .description("List 5 input modalities with weights")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const rows = MODALITIES.map((m) => ({
+        modality: m,
+        weight: MODALITY_WEIGHTS[m],
+      }));
+      if (opts.json) return console.log(JSON.stringify(rows, null, 2));
+      for (const r of rows)
+        console.log(`  ${r.modality.padEnd(10)} weight=${r.weight}`);
+    });
+
+  mm.command("input-formats")
+    .description("List 7 supported document formats (4 native)")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const r = getSupportedFormats();
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log("Formats:", r.formats.join(", "));
+      console.log("Native:  ", r.native.join(", "));
+    });
+
+  mm.command("output-formats")
+    .description("List 6 output formats")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const r = getOutputFormats();
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      for (const f of r) console.log(`  ${f}`);
+    });
+
+  mm.command("statuses")
+    .description("List session statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const s = Object.values(SESSION_STATUS);
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      for (const x of s) console.log(`  ${x}`);
+    });
+
+  /* ── Sessions ─────────────────────────────────────── */
+
+  mm.command("session-create")
+    .description("Create a multimodal session")
+    .option("-t, --title <title>", "Session title")
+    .option("-m, --meta <json>", "Metadata JSON")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(mm);
+      const r = createSession(db, {
+        title: opts.title,
+        metadata: _parseJson(opts.meta),
+      });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Session created: ${r.sessionId}`);
+    });
+
+  mm.command("session-show <sessionId>")
+    .description("Show session details")
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const s = getSession(db, sessionId);
+      if (!s) return console.log("Not found");
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(`ID:         ${s.id}`);
+      console.log(`Status:     ${s.status}`);
+      console.log(`Modalities: ${s.modalities.join(", ") || "-"}`);
+      console.log(`Tokens:     ${s.tokenCount}`);
+      console.log(`Created:    ${new Date(s.createdAt).toISOString()}`);
+    });
+
+  mm.command("sessions")
+    .description("List sessions")
+    .option("-s, --status <status>", "Filter by status")
+    .option("-n, --limit <n>", "Limit", (v) => parseInt(v, 10), 50)
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(mm);
+      const rows = listSessions(db, { status: opts.status, limit: opts.limit });
+      if (opts.json) return console.log(JSON.stringify(rows, null, 2));
+      if (rows.length === 0) return console.log("No sessions");
+      for (const r of rows)
+        console.log(
+          `  ${r.id.slice(0, 8)}…  ${r.status.padEnd(10)}  tok=${String(r.tokenCount).padStart(5)}  [${r.modalities.join(",")}]`,
+        );
+    });
+
+  mm.command("session-complete <sessionId>")
+    .description("Mark session as completed")
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const r = completeSession(db, sessionId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r.completed) return console.log(`Failed: ${r.reason}`);
+      console.log("Session completed");
+    });
+
+  mm.command("session-delete <sessionId>")
+    .description("Delete session and all artifacts")
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const r = deleteSession(db, sessionId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r.deleted) return console.log(`Failed: ${r.reason}`);
+      console.log("Session deleted");
+    });
+
+  /* ── Modalities ───────────────────────────────────── */
+
+  mm.command("add <sessionId>")
+    .description("Add a modality input to a session")
+    .requiredOption(
+      "-m, --modality <type>",
+      "Modality (text|document|image|audio|screen)",
+    )
+    .option("-f, --file <path>", "Read content from file")
+    .option("-t, --text <text>", "Inline text content")
+    .option("-d, --data <json>", "Inline JSON content")
+    .option("--meta <json>", "Metadata JSON")
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const data = _readData(opts);
+      if (data == null)
+        return console.log("Must provide --file, --text, or --data");
+      const r = addModality(db, sessionId, opts.modality, data, {
+        metadata: _parseJson(opts.meta),
+      });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r.added) return console.log(`Failed: ${r.reason}`);
+      console.log(`Added ${r.modality} modality (artifact=${r.artifactId})`);
+    });
+
+  mm.command("modalities-of <sessionId>")
+    .description("List modalities added to a session")
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const r = getSessionModalities(db, sessionId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      for (const [m, items] of Object.entries(r))
+        console.log(`  ${m.padEnd(10)} ${items.length} item(s)`);
+    });
+
+  mm.command("fuse <sessionId>")
+    .description("Weighted fusion of all input artifacts")
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const r = fuse(db, sessionId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r.fused) return console.log(`Failed: ${r.reason}`);
+      console.log(
+        `Fused ${r.summary.length} modalities (weight=${r.totalWeight}, tokens~${r.tokenEstimate})`,
+      );
+      for (const s of r.summary)
+        console.log(`  ${s.modality.padEnd(10)} n=${s.count} w=${s.weight}`);
+    });
+
+  /* ── Parsing ──────────────────────────────────────── */
+
+  mm.command("parse <filePath>")
+    .description("Parse a document (txt/md/csv/json native)")
+    .option("--json", "JSON output")
+    .action((filePath, opts) => {
+      const r = parseDocument(filePath);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r.parsed)
+        return console.log(
+          `Failed: ${r.reason}${r.hint ? `\n  ${r.hint}` : ""}`,
+        );
+      console.log(
+        `Parsed ${r.format}: length=${r.length}, tokens~${r.tokenEstimate}`,
+      );
+      if (r.rowCount != null) console.log(`Rows: ${r.rowCount}`);
+    });
+
+  /* ── Context ──────────────────────────────────────── */
+
+  mm.command("build-context <sessionId>")
+    .description("Build context from session artifacts")
+    .option(
+      "-t, --max-tokens <n>",
+      "Max tokens",
+      (v) => parseInt(v, 10),
+      DEFAULT_MAX_TOKENS,
+    )
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const r = buildContext(db, sessionId, { maxTokens: opts.maxTokens });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r.built) return console.log(`Failed: ${r.reason}`);
+      console.log(
+        `Built context: ${r.tokens}/${r.maxTokens} tokens across ${r.itemCount} items`,
+      );
+    });
+
+  mm.command("get-context <sessionId>")
+    .description("Get cached/stored context")
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const r = getContext(db, sessionId);
+      if (!r) return console.log("No context built yet");
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Tokens: ${r.tokens}/${r.maxTokens}`);
+      console.log(`Items:  ${r.items?.length || 0}`);
+      if (r.content) console.log(`\n--- content ---\n${r.content}`);
+    });
+
+  mm.command("clear-context <sessionId>")
+    .description("Clear the session's context")
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const r = clearContext(db, sessionId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r.cleared) return console.log(`Failed: ${r.reason}`);
+      console.log("Context cleared");
+    });
+
+  mm.command("trim-context <sessionId>")
+    .description("Trim current context to max tokens")
+    .requiredOption("-t, --max-tokens <n>", "Max tokens", (v) =>
+      parseInt(v, 10),
+    )
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const ctx = getContext(db, sessionId);
+      if (!ctx) return console.log("No context built yet");
+      const r = trimContext(ctx, opts.maxTokens);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r.trimmed) return console.log(`Failed: ${r.reason}`);
+      console.log(
+        `Trimmed to ${r.tokens}/${r.maxTokens} tokens (${r.items.length} items)`,
+      );
+    });
+
+  /* ── Output generation ────────────────────────────── */
+
+  mm.command("generate")
+    .description("Generate output in one of 6 formats")
+    .requiredOption("-f, --format <format>", "Output format")
+    .option("-s, --session <id>", "Session to attach artifact")
+    .option("-c, --content <text>", "Inline content")
+    .option("--file <path>", "Read content from file")
+    .option("--data <json>", "Inline JSON content")
+    .option("-o, --out <path>", "Write output to file")
+    .option("--title <title>", "Optional title")
+    .option("--chart-type <type>", "Chart type for chart format", "line")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(mm);
+      let content;
+      if (opts.file) content = fs.readFileSync(opts.file, "utf-8");
+      else if (opts.data) content = _parseJson(opts.data);
+      else content = opts.content ?? "";
+      const r = generateOutput(db, opts.session, content, opts.format, {
+        title: opts.title,
+        chartType: opts.chartType,
+      });
+      if (!r.generated)
+        return console.log(
+          `Failed: ${r.reason}${r.format ? ` (format=${r.format})` : ""}`,
+        );
+      if (opts.out) {
+        fs.writeFileSync(opts.out, r.content);
+        console.log(`Wrote ${r.size} bytes to ${opts.out}`);
+        return;
+      }
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`--- ${r.format} (${r.size} bytes) ---`);
+      console.log(r.content);
+    });
+
+  /* ── Artifacts ────────────────────────────────────── */
+
+  mm.command("artifacts <sessionId>")
+    .description("List artifacts for a session")
+    .option("-t, --type <type>", "input|output")
+    .option("-m, --modality <m>", "Filter by modality")
+    .option("-n, --limit <n>", "Limit", (v) => parseInt(v, 10), 100)
+    .option("--json", "JSON output")
+    .action((sessionId, opts) => {
+      const db = _dbFromCtx(mm);
+      const rows = listArtifacts(db, sessionId, {
+        type: opts.type,
+        modality: opts.modality,
+        limit: opts.limit,
+      });
+      if (opts.json) return console.log(JSON.stringify(rows, null, 2));
+      if (rows.length === 0) return console.log("No artifacts");
+      for (const a of rows) {
+        const head =
+          typeof a.content === "string"
+            ? a.content.slice(0, 40).replace(/\n/g, " ")
+            : "(json)";
+        console.log(
+          `  ${a.id.slice(0, 8)}…  ${a.type.padEnd(6)}  ${(a.modality || a.format || "-").padEnd(10)}  ${head}`,
+        );
+      }
+    });
+
+  /* ── Stats ────────────────────────────────────────── */
+
+  mm.command("stats")
+    .description("Multimodal system statistics")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(mm);
+      const s = getMultimodalStats(db);
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(`Sessions:  ${s.sessions}`);
+      console.log(
+        `Artifacts: ${s.artifacts} (in=${s.inputs}, out=${s.outputs})`,
+      );
+      console.log(`Tokens:    ${s.totalTokens}`);
+      console.log("By status:");
+      for (const [k, v] of Object.entries(s.byStatus))
+        console.log(`  ${k}: ${v}`);
+      console.log("By modality:");
+      for (const [k, v] of Object.entries(s.byModality))
+        console.log(`  ${k}: ${v}`);
+    });
+
+  program.addCommand(mm);
+}