chainlesschain 0.47.6 → 0.47.8

package/src/commands/session.js

@@ -450,6 +450,256 @@ export function registerSessionCommand(program) {
       }
     });
 
+  // ---------------------------------------------------------------
+  // session-core SessionManager lifecycle (Phase H — CLI parity)
+  // Parked sessions persist to ~/.chainlesschain/parked-sessions.json
+  // ---------------------------------------------------------------
+  session
+    .command("lifecycle")
+    .description("List session-core handles (running/idle/parked)")
+    .option("--status <s>", "Filter by status: running | idle | parked")
+    .option("--agent <id>", "Filter by agent id")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { getSessionManager } =
+          await import("../lib/session-core-singletons.js");
+        const mgr = getSessionManager();
+        const live = mgr.list({
+          agentId: options.agent,
+          status: options.status,
+        });
+        let parked = [];
+        if (mgr._parkedStore) {
+          const all = await mgr._parkedStore.list();
+          parked = all
+            .filter((s) => !options.agent || s.agentId === options.agent)
+            .filter((s) => !options.status || s.status === options.status);
+        }
+        const merged = [
+          ...live.map((h) => h.toJSON()),
+          ...parked.filter(
+            (p) => !live.some((h) => h.sessionId === p.sessionId),
+          ),
+        ];
+        if (options.json) {
+          console.log(JSON.stringify(merged, null, 2));
+          return;
+        }
+        if (merged.length === 0) {
+          logger.info("No session-core handles");
+          return;
+        }
+        for (const h of merged) {
+          logger.log(
+            `${chalk.gray(h.sessionId.slice(0, 12))}  ${chalk.cyan(h.status.padEnd(7))}  agent=${h.agentId || "-"}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  session
+    .command("park")
+    .description("Park a session (persist to disk, free process memory)")
+    .argument("<id>", "Session ID")
+    .action(async (id) => {
+      try {
+        const { getSessionManager } =
+          await import("../lib/session-core-singletons.js");
+        const mgr = getSessionManager();
+        if (!mgr.has(id)) {
+          logger.error(`Session ${id} is not active in this process`);
+          process.exit(1);
+        }
+        mgr.markIdle(id);
+        const ok = await mgr.park(id);
+        if (!ok) {
+          logger.error(`Failed to park ${id}`);
+          process.exit(1);
+        }
+        logger.success(`Session ${chalk.gray(id.slice(0, 12))} parked`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  session
+    .command("unpark")
+    .description("Resume a parked session")
+    .argument("<id>", "Session ID")
+    .action(async (id) => {
+      try {
+        const { getSessionManager } =
+          await import("../lib/session-core-singletons.js");
+        const mgr = getSessionManager();
+        const ok = await mgr.resume(id);
+        if (!ok) {
+          logger.error(`No parked session ${id}`);
+          process.exit(1);
+        }
+        logger.success(`Session ${chalk.gray(id.slice(0, 12))} resumed`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  session
+    .command("end")
+    .description(
+      "Close a session (optionally consolidate trace into MemoryStore)",
+    )
+    .argument("<id>", "Session ID")
+    .option(
+      "--consolidate",
+      "Consolidate JSONL trace into MemoryStore before closing",
+    )
+    .option("--scope <s>", "Memory scope for consolidation", "session")
+    .option("--scope-id <id>", "Scope id (defaults to session id)")
+    .option("--agent-id <id>", "Agent id for scope=agent")
+    .action(async (id, options) => {
+      try {
+        const { getSessionManager } =
+          await import("../lib/session-core-singletons.js");
+        if (options.consolidate) {
+          try {
+            const { consolidateJsonlSession } =
+              await import("../lib/session-consolidator.js");
+            const res = await consolidateJsonlSession(id, {
+              scope: options.scope,
+              scopeId: options.scopeId || null,
+              agentId: options.agentId || null,
+            });
+            await new Promise((r) => setImmediate(r));
+            logger.info(
+              `Consolidated ${res.writtenCount} memory entries from session trace`,
+            );
+          } catch (e) {
+            logger.warn(`Consolidation skipped: ${e.message}`);
+          }
+        }
+        const mgr = getSessionManager();
+        const ok = await mgr.close(id);
+        if (!ok && mgr._parkedStore) {
+          await mgr._parkedStore.remove(id);
+        }
+        logger.success(`Session ${chalk.gray(id.slice(0, 12))} closed`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ---------------------------------------------------------------
+  // session tail <id> — Phase I: follow JSONL events as NDJSON
+  // ---------------------------------------------------------------
+  session
+    .command("tail")
+    .description("Follow a JSONL session's events (NDJSON on stdout)")
+    .argument("<id>", "Session ID")
+    .option("--from-start", "Start from the first event (default: EOF)")
+    .option("--from-offset <n>", "Start from explicit byte offset")
+    .option("-t, --type <types>", "Comma-separated event types to include")
+    .option("--since <ms>", "Only events with timestamp >= ms")
+    .option("--once", "Drain current tail and exit (no follow)")
+    .option("--poll <ms>", "Poll interval", "200")
+    .action(async (id, options) => {
+      try {
+        const { followSession } = await import("../lib/session-tail.js");
+        const controller = new AbortController();
+        const onSig = () => controller.abort();
+        process.once("SIGINT", onSig);
+        process.once("SIGTERM", onSig);
+        const types = options.type
+          ? options.type
+              .split(",")
+              .map((s) => s.trim())
+              .filter(Boolean)
+          : null;
+        const iter = followSession(id, {
+          signal: controller.signal,
+          pollMs: parseInt(options.poll, 10) || 200,
+          fromStart: Boolean(options.fromStart),
+          fromOffset:
+            options.fromOffset !== undefined
+              ? parseInt(options.fromOffset, 10)
+              : undefined,
+          types,
+          sinceMs: options.since ? parseInt(options.since, 10) : null,
+          once: Boolean(options.once),
+        });
+        for await (const { event } of iter) {
+          process.stdout.write(JSON.stringify(event) + "\n");
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ---------------------------------------------------------------
+  // session usage [id] — Phase I: aggregate token usage
+  // ---------------------------------------------------------------
+  session
+    .command("usage")
+    .description("Aggregate token usage (per-session or global)")
+    .argument("[id]", "Session ID (omit for global rollup)")
+    .option("--json", "Output as JSON")
+    .option("--limit <n>", "Max sessions for global rollup", "1000")
+    .action(async (id, options) => {
+      try {
+        const { sessionUsage, allSessionsUsage } =
+          await import("../lib/session-usage.js");
+        const result = id
+          ? sessionUsage(id)
+          : allSessionsUsage({ limit: parseInt(options.limit, 10) || 1000 });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        if (id) {
+          logger.log(chalk.bold(`Session ${chalk.gray(id.slice(0, 16))}`));
+          const t = result.total;
+          logger.log(
+            `  total: ${chalk.cyan(t.totalTokens.toLocaleString())} tokens  in=${t.inputTokens}  out=${t.outputTokens}  calls=${t.calls}`,
+          );
+          if (result.byModel.length === 0) {
+            logger.log(chalk.gray("  (no token_usage events recorded)"));
+            return;
+          }
+          for (const row of result.byModel) {
+            logger.log(
+              `  ${chalk.gray((row.provider || "?").padEnd(10))} ${chalk.white((row.model || "?").padEnd(24))} in=${row.inputTokens}  out=${row.outputTokens}  calls=${row.calls}`,
+            );
+          }
+        } else {
+          const t = result.total;
+          logger.log(chalk.bold("Global usage"));
+          logger.log(
+            `  total: ${chalk.cyan(t.totalTokens.toLocaleString())} tokens  in=${t.inputTokens}  out=${t.outputTokens}  calls=${t.calls}  sessions=${result.sessions.length}`,
+          );
+          if (result.byModel.length === 0) {
+            logger.log(chalk.gray("  (no token_usage events recorded)"));
+            return;
+          }
+          for (const row of result.byModel) {
+            logger.log(
+              `  ${chalk.gray((row.provider || "?").padEnd(10))} ${chalk.white((row.model || "?").padEnd(24))} in=${row.inputTokens}  out=${row.outputTokens}  calls=${row.calls}`,
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
   // session workflow — inspect canonical coding workflow state
   // Reads .chainlesschain/sessions/<id>/{intent.md,plan.md,progress.log,mode.json}
   // written by the 4 workflow skills ($deep-interview/$ralplan/$ralph/$team).

package/src/commands/stream.js

@@ -0,0 +1,75 @@
+/**
+ * chainlesschain stream "<prompt>" — scriptable StreamRouter demo.
+ *
+ * Mirrors Desktop's `agent:stream:start` IPC: feed a provider stream through
+ * session-core StreamRouter and emit StreamEvent objects as NDJSON on stdout
+ * so downstream scripts can consume them line-by-line.
+ *
+ * Managed Agents parity Phase H — CLI symmetric entry.
+ * Provider adapters live in `../lib/provider-stream.js` so the WS
+ * `stream.run` route can reuse them (Phase I).
+ */
+
+import { logger } from "../lib/logger.js";
+import { loadConfig } from "../lib/config-manager.js";
+import { buildProviderSource } from "../lib/provider-stream.js";
+
+export function registerStreamCommand(program) {
+  program
+    .command("stream")
+    .description(
+      "Stream a single prompt through session-core StreamRouter (NDJSON on stdout)",
+    )
+    .argument("<prompt>", "The prompt to stream")
+    .option("--model <model>", "Model name")
+    .option("--provider <provider>", "LLM provider", "ollama")
+    .option("--base-url <url>", "API base URL")
+    .option("--api-key <key>", "API key")
+    .option("--text", "Emit concatenated final text instead of NDJSON events")
+    .action(async (prompt, options) => {
+      const config = loadConfig();
+      const provider = options.provider || config.llm?.provider || "ollama";
+      const baseUrl = options.baseUrl || config.llm?.baseUrl;
+      const apiKey = options.apiKey || config.llm?.apiKey;
+      const model = options.model || config.llm?.model;
+
+      try {
+        const { createStreamRouter } =
+          await import("../lib/session-core-singletons.js");
+        const router = createStreamRouter();
+        const source = buildProviderSource(provider, {
+          model,
+          baseUrl,
+          apiKey,
+          prompt,
+        });
+
+        if (options.text) {
+          const out = await router.collect(source);
+          if (out.errored) {
+            logger.error(`Stream errored: ${out.error?.message || out.error}`);
+            process.exit(1);
+          }
+          process.stdout.write(out.text);
+          if (!out.text.endsWith("\n")) process.stdout.write("\n");
+          return;
+        }
+
+        for await (const ev of router.stream(source)) {
+          process.stdout.write(`${JSON.stringify(ev)}\n`);
+        }
+      } catch (err) {
+        const ev = {
+          type: "error",
+          error: err.message,
+          ts: Date.now(),
+        };
+        if (options.text) {
+          logger.error(`Failed: ${err.message}`);
+        } else {
+          process.stdout.write(`${JSON.stringify(ev)}\n`);
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/video.js

@@ -0,0 +1,363 @@
+/**
+ * cc video — 视频剪辑 Agent (借鉴 CutClaw)
+ *
+ * 子命令：
+ *  edit          一键完整流程
+ *  deconstruct   解构素材（抽帧+ASR+beat）
+ *  plan          生成 shot_plan
+ *  assemble      Editor ReAct 选时间戳
+ *  render        ffmpeg 渲染成片
+ *  assets        管理已解构素材缓存
+ */
+
+import { logger } from "../lib/logger.js";
+
+export function registerVideoCommand(program) {
+  const video = program
+    .command("video")
+    .description(
+      "Video editing agent — long footage + music → montage (CutClaw-inspired)",
+    );
+
+  // ── cc video edit ─────────────────────────────────────────
+  video
+    .command("edit")
+    .description("Full pipeline: deconstruct → plan → assemble → render")
+    .requiredOption("--video <path>", "Input video file")
+    .option("--audio <path>", "Background music file")
+    .option("--instruction <text>", "Editing instruction", "")
+    .option("--output <path>", "Output video path", "./output.mp4")
+    .option("--srt <path>", "Existing subtitle file (skip ASR)")
+    .option("--fps <n>", "Frame sampling FPS", "2")
+    .option("--character <name>", "Main character name")
+    .option("--parallel", "Run sections in parallel with conflict resolution")
+    .option("--concurrency <n>", "Max parallel sections", "4")
+    .option("--review", "Enable quality gate (VLM review before commit)")
+    .option("--use-madmom", "Use madmom Python sidecar for beat detection")
+    .option("--snap-beats", "Snap shot plan timestamps to nearest beat")
+    .option("--ducking", "Enable dialogue ducking in audio mix")
+    .option("--stream", "Emit NDJSON progress events to stdout")
+    .option("--json", "JSON final output")
+    .action(async (options) => {
+      const { VideoPipeline } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const pipeline = new VideoPipeline({
+        videoPath: options.video,
+        audioPath: options.audio,
+        instruction: options.instruction,
+        outputPath: options.output,
+        existingSrt: options.srt,
+        fps: parseInt(options.fps, 10),
+        mainCharacter: options.character,
+        useMadmom: !!options.useMadmom,
+        snapBeats: !!options.snapBeats,
+        ducking: !!options.ducking,
+      });
+
+      if (options.stream) {
+        pipeline.on("event", (ev) => {
+          process.stdout.write(`${JSON.stringify(ev)}\n`);
+        });
+      } else {
+        pipeline.on("event", (ev) => {
+          if (ev.type === "phase.start") logger.info(`▶ ${ev.phase}`);
+          if (ev.type === "phase.progress")
+            logger.info(`  ${ev.pct * 100}% ${ev.message || ""}`);
+          if (ev.type === "phase.end") logger.info(`✓ ${ev.phase} done`);
+          if (ev.type === "error") logger.error(`✗ ${ev.phase}: ${ev.error}`);
+        });
+      }
+
+      try {
+        const runOpts = {
+          parallel: !!options.parallel,
+          maxConcurrency: parseInt(options.concurrency, 10),
+        };
+        const result = options.review
+          ? await pipeline.runWithReview(runOpts)
+          : await pipeline.run(runOpts);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (!options.stream) {
+          logger.info(`\nOutput: ${result.outputPath}`);
+        }
+      } catch (err) {
+        if (options.stream) {
+          process.stdout.write(
+            `${JSON.stringify({ type: "error", error: err.message, ts: Date.now() })}\n`,
+          );
+        }
+        logger.error(`Video edit failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video deconstruct ──────────────────────────────────
+  video
+    .command("deconstruct")
+    .description("Extract frames + ASR + beat analysis (results cached)")
+    .requiredOption("--video <path>", "Input video file")
+    .option("--audio <path>", "Audio file for beat analysis")
+    .option("--srt <path>", "Existing subtitle file")
+    .option("--fps <n>", "Frame sampling FPS", "2")
+    .option("--use-madmom", "Use madmom for beat detection")
+    .option("--stream", "NDJSON events")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+      const { VideoPipeline } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const pipeline = new VideoPipeline({
+        videoPath: options.video,
+        audioPath: options.audio,
+        existingSrt: options.srt,
+        fps: parseInt(options.fps, 10),
+        useMadmom: !!options.useMadmom,
+      });
+
+      if (options.stream) {
+        pipeline.on("event", (ev) =>
+          process.stdout.write(`${JSON.stringify(ev)}\n`),
+        );
+      }
+
+      try {
+        const dir = await pipeline.deconstruct();
+        if (options.json) {
+          console.log(
+            JSON.stringify({ assetDir: dir, hash: dir.split(/[/\\]/).pop() }),
+          );
+        } else if (!options.stream) {
+          logger.info(`Assets cached: ${dir}`);
+        }
+      } catch (err) {
+        logger.error(`Deconstruct failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video plan ─────────────────────────────────────────
+  video
+    .command("plan")
+    .description("Generate shot_plan from deconstructed assets + instruction")
+    .requiredOption("--asset-dir <path>", "Deconstructed asset directory")
+    .option("--instruction <text>", "Editing instruction", "")
+    .option("--character <name>", "Main character name")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+      const { VideoPipeline } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const pipeline = new VideoPipeline({
+        videoPath: "",
+        instruction: options.instruction,
+        mainCharacter: options.character,
+        cacheDir: options.assetDir,
+      });
+
+      try {
+        const plan = await pipeline.plan(options.assetDir);
+        if (options.json) {
+          console.log(JSON.stringify(plan, null, 2));
+        } else {
+          const shots = (plan.sections || []).reduce(
+            (s, sec) => s + (sec.shots?.length || 0),
+            0,
+          );
+          logger.info(
+            `Shot plan: ${plan.sections?.length || 0} sections, ${shots} shots`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Plan failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video assemble ─────────────────────────────────────
+  video
+    .command("assemble")
+    .description("Run Editor ReAct loop to select timestamps from shot_plan")
+    .requiredOption("--asset-dir <path>", "Deconstructed asset directory")
+    .requiredOption("--plan <path>", "shot_plan.json path")
+    .option("--parallel", "Run sections in parallel with conflict resolution")
+    .option("--concurrency <n>", "Max parallel sections", "4")
+    .option("--review", "Enable quality gate (VLM review before commit)")
+    .option("--stream", "NDJSON events")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+      const { promises: fs } = await import("fs");
+      const { VideoPipeline } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const shotPlan = JSON.parse(await fs.readFile(options.plan, "utf-8"));
+      const pipeline = new VideoPipeline({
+        videoPath: "",
+        cacheDir: options.assetDir,
+      });
+
+      if (options.stream) {
+        pipeline.on("event", (ev) =>
+          process.stdout.write(`${JSON.stringify(ev)}\n`),
+        );
+      }
+
+      try {
+        let points;
+        if (options.parallel) {
+          points = await pipeline.assembleParallel(shotPlan, options.assetDir, {
+            maxConcurrency: parseInt(options.concurrency, 10),
+          });
+        } else {
+          points = await pipeline.assemble(shotPlan, options.assetDir);
+        }
+
+        if (options.review) {
+          const { approved } = await pipeline.review(points, options.assetDir);
+          points = approved;
+        }
+        if (options.json) {
+          console.log(JSON.stringify(points, null, 2));
+        } else if (!options.stream) {
+          logger.info(`Assembled ${points.length} shot points`);
+        }
+      } catch (err) {
+        logger.error(`Assemble failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video render ───────────────────────────────────────
+  video
+    .command("render")
+    .description("Render shot_point.json into final video via ffmpeg")
+    .requiredOption("--video <path>", "Original video file")
+    .requiredOption("--points <path>", "shot_point.json path")
+    .option("--audio <path>", "Background music to mix")
+    .option("--output <path>", "Output path", "./output.mp4")
+    .option("--stream", "NDJSON events")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+      const { promises: fs } = await import("fs");
+      const { VideoPipeline, getCacheDir } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const shotPoints = JSON.parse(await fs.readFile(options.points, "utf-8"));
+      const pipeline = new VideoPipeline({
+        videoPath: options.video,
+        audioPath: options.audio,
+        outputPath: options.output,
+        cacheDir: getCacheDir(options.video, options.audio),
+      });
+
+      if (options.stream) {
+        pipeline.on("event", (ev) =>
+          process.stdout.write(`${JSON.stringify(ev)}\n`),
+        );
+      }
+
+      try {
+        const outPath = await pipeline.render(shotPoints);
+        if (options.json) {
+          console.log(JSON.stringify({ outputPath: outPath }));
+        } else if (!options.stream) {
+          logger.info(`Rendered: ${outPath}`);
+        }
+      } catch (err) {
+        logger.error(`Render failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video assets ───────────────────────────────────────
+  video
+    .command("assets")
+    .description("Manage deconstructed video asset cache")
+    .argument("[action]", "list | show | prune", "list")
+    .option("--hash <hash>", "Asset hash to show")
+    .option("--older-than <days>", "Prune assets older than N days")
+    .option("--json", "JSON output")
+    .action(async (action, options) => {
+      const { promises: fs } = await import("fs");
+      const pathMod = await import("path");
+
+      const base = process.env.APPDATA
+        ? pathMod.join(
+            process.env.APPDATA,
+            "chainlesschain-desktop-vue",
+            ".chainlesschain",
+            "video-editing",
+          )
+        : pathMod.join(
+            process.env.HOME || "~",
+            ".chainlesschain",
+            "video-editing",
+          );
+
+      if (action === "list") {
+        try {
+          const dirs = await fs.readdir(base);
+          const assets = [];
+          for (const d of dirs) {
+            const metaPath = pathMod.join(base, d, "meta.json");
+            try {
+              const meta = JSON.parse(await fs.readFile(metaPath, "utf-8"));
+              const stat = await fs.stat(metaPath);
+              assets.push({
+                hash: d,
+                ...meta,
+                modifiedAt: stat.mtime.toISOString(),
+              });
+            } catch {}
+          }
+          if (options.json) {
+            console.log(JSON.stringify({ assets }, null, 2));
+          } else {
+            if (assets.length === 0) {
+              logger.info("No cached assets.");
+            } else {
+              for (const a of assets) {
+                logger.info(
+                  `${a.hash}  ${a.videoPath || "?"}  ${a.modifiedAt}`,
+                );
+              }
+            }
+          }
+        } catch {
+          logger.info("No cached assets.");
+        }
+      } else if (action === "show" && options.hash) {
+        const dir = pathMod.join(base, options.hash);
+        try {
+          const files = await fs.readdir(dir);
+          if (options.json) {
+            console.log(JSON.stringify({ hash: options.hash, files }));
+          } else {
+            logger.info(`Asset ${options.hash}:`);
+            for (const f of files) logger.info(`  ${f}`);
+          }
+        } catch {
+          logger.error(`Asset not found: ${options.hash}`);
+        }
+      } else if (action === "prune") {
+        const days = parseInt(options.olderThan || "30", 10);
+        const cutoff = Date.now() - days * 86400000;
+        try {
+          const dirs = await fs.readdir(base);
+          let removed = 0;
+          for (const d of dirs) {
+            const dirPath = pathMod.join(base, d);
+            const stat = await fs.stat(dirPath);
+            if (stat.mtimeMs < cutoff) {
+              await fs.rm(dirPath, { recursive: true, force: true });
+              removed++;
+            }
+          }
+          logger.info(`Pruned ${removed} asset(s) older than ${days} days.`);
+        } catch {
+          logger.info("Nothing to prune.");
+        }
+      }
+    });
+}