multiclaw 0.7.0 → 0.8.1

package/dist/commands/prune.d.ts

@@ -0,0 +1,28 @@
+export interface PruneOptions {
+    config?: string;
+    history?: boolean;
+    runs?: boolean;
+    all?: boolean;
+    dryRun?: boolean;
+    yes?: boolean;
+}
+export interface PruneItem {
+    id: string;
+    label: string;
+    path: string;
+    size: number;
+    kind: "history" | "run" | "all-runs";
+}
+/** Scan `.multiclaw/` and list prune-able items with their sizes. */
+export declare function scanPruneItems(workDir: string): PruneItem[];
+/** Delete the selected items. Returns what was removed. */
+export declare function deletePruneItems(items: PruneItem[]): {
+    deleted: string[];
+    failed: Array<{
+        path: string;
+        error: string;
+    }>;
+};
+/** Resolve non-interactive flags into item ids, or undefined if interactive. */
+export declare function resolvePruneTargets(options: PruneOptions, items: PruneItem[]): string[] | undefined;
+export declare function pruneCommand(options: PruneOptions): Promise<void>;

package/dist/commands/prune.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/resume.d.ts

@@ -1,4 +1,4 @@
-import type { MultiClawConfig, OrchestratorResult } from "@multiclawcli/core";
+import type { OrchestratorResult } from "@multiclawcli/core";
 /** A previous run's report, as much of it as resume needs. */
 export interface ResumeTarget {
     runDir: string;
@@ -28,5 +28,8 @@ export declare function readReport(runDir: string): OrchestratorResult;
  */
 export declare function resumeOptionsFromReport(report: OrchestratorResult, requirementOverride?: string): {
     requirement: string;
-    resume: NonNullable<MultiClawConfig["resume"]>;
+    resume: {
+        agents: string[];
+        sessions?: Record<string, string>;
+    };
 };

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname4, join as join5 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
 
@@ -468,9 +468,217 @@ async function initCommand() {
   );
 }
 
+// src/commands/prune.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { checkbox as checkbox2, confirm } from "@inquirer/prompts";
+function scanPruneItems(workDir) {
+  const items = [];
+  const multiclawDir = path3.join(workDir, ".multiclaw");
+  const historyFile = path3.join(multiclawDir, "console", "history.json");
+  if (fs3.existsSync(historyFile)) {
+    const stat = fs3.statSync(historyFile);
+    const raw = fs3.readFileSync(historyFile, "utf-8");
+    let turns = 0;
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) turns = parsed.length;
+    } catch {
+    }
+    items.push({
+      id: "history",
+      label: `Console history (${turns} turn${turns === 1 ? "" : "s"}, ${formatBytes(stat.size)})`,
+      path: historyFile,
+      size: stat.size,
+      kind: "history"
+    });
+  }
+  const runsDir = path3.join(multiclawDir, "runs");
+  if (fs3.existsSync(runsDir)) {
+    const entries = fs3.readdirSync(runsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("run-")).sort((a, b) => a.name.localeCompare(b.name));
+    let totalRunsSize = 0;
+    for (const entry of entries) {
+      const runPath = path3.join(runsDir, entry.name);
+      const size = dirSize(runPath);
+      totalRunsSize += size;
+      const agentCount = countAgentsInRun(runPath);
+      items.push({
+        id: entry.name,
+        label: `${entry.name}  (${agentCount} agent${agentCount === 1 ? "" : "s"}, ${formatBytes(size)})`,
+        path: runPath,
+        size,
+        kind: "run"
+      });
+    }
+    if (entries.length > 1) {
+      items.push({
+        id: "all-runs",
+        label: `All runs (${entries.length} total, ${formatBytes(totalRunsSize)})`,
+        path: runsDir,
+        size: totalRunsSize,
+        kind: "all-runs"
+      });
+    }
+  }
+  return items;
+}
+function deletePruneItems(items) {
+  const deleted = [];
+  const failed = [];
+  for (const item of items) {
+    try {
+      if (item.kind === "history") {
+        fs3.unlinkSync(item.path);
+        deleted.push(item.id);
+      } else if (item.kind === "run") {
+        fs3.rmSync(item.path, { recursive: true, force: true });
+        deleted.push(item.id);
+      } else if (item.kind === "all-runs") {
+        const runsDir = item.path;
+        const entries = fs3.readdirSync(runsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("run-"));
+        for (const entry of entries) {
+          fs3.rmSync(path3.join(runsDir, entry.name), { recursive: true, force: true });
+        }
+        try {
+          fs3.rmdirSync(runsDir);
+        } catch {
+        }
+        deleted.push(item.id);
+      }
+    } catch (err) {
+      failed.push({ path: item.path, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { deleted, failed };
+}
+function resolvePruneTargets(options, items) {
+  if (options.all) {
+    return items.map((i) => i.id);
+  }
+  if (options.history && options.runs) {
+    return items.map((i) => i.id);
+  }
+  if (options.history) {
+    return items.filter((i) => i.kind === "history").map((i) => i.id);
+  }
+  if (options.runs) {
+    return items.filter((i) => i.kind === "run" || i.kind === "all-runs").map((i) => i.id);
+  }
+  return void 0;
+}
+async function pruneCommand(options) {
+  const config = await loadConfig(options.config);
+  const items = scanPruneItems(config.workDir);
+  if (items.length === 0) {
+    console.log("Nothing to prune \u2014 no history or runs found.");
+    return;
+  }
+  let selectedIds;
+  const nonInteractive = resolvePruneTargets(options, items);
+  if (nonInteractive !== void 0) {
+    selectedIds = nonInteractive;
+  } else {
+    const choices = items.map((item) => ({
+      value: item.id,
+      name: item.label
+    }));
+    selectedIds = await checkbox2({
+      message: "Select items to prune (space to select, enter to confirm):",
+      choices
+    });
+  }
+  if (selectedIds.length === 0) {
+    console.log("No items selected \u2014 nothing pruned.");
+    return;
+  }
+  const selected = items.filter((i) => selectedIds.includes(i.id));
+  const totalSize = selected.reduce((sum, i) => sum + i.size, 0);
+  if (options.dryRun) {
+    console.log("");
+    console.log("\x1B[2mDry run \u2014 the following would be deleted:\x1B[0m");
+    for (const item of selected) {
+      console.log(`  \x1B[31m- ${item.label}\x1B[0m`);
+    }
+    console.log(`
+  Total: ${formatBytes(totalSize)}`);
+    return;
+  }
+  if (!options.yes) {
+    const ok = await confirm({
+      message: `Delete ${selected.length} item${selected.length === 1 ? "" : "s"} (${formatBytes(totalSize)})? This cannot be undone.`,
+      default: false
+    });
+    if (!ok) {
+      console.log("Cancelled \u2014 nothing pruned.");
+      return;
+    }
+  }
+  const { deleted, failed } = deletePruneItems(selected);
+  console.log("");
+  if (deleted.length > 0) {
+    console.log(
+      `\x1B[32m\u2713\x1B[0m Pruned ${deleted.length} item${deleted.length === 1 ? "" : "s"} (${formatBytes(totalSize)} freed)`
+    );
+    for (const id of deleted) {
+      const item = items.find((i) => i.id === id);
+      if (item) console.log(`  \x1B[2m- ${item.label}\x1B[0m`);
+    }
+  }
+  if (failed.length > 0) {
+    console.log("");
+    console.log(
+      `\x1B[31m\u2717\x1B[0m Failed to delete ${failed.length} item${failed.length === 1 ? "" : "s"}:`
+    );
+    for (const { path: p, error } of failed) {
+      console.log(`  \x1B[31m- ${p}: ${error}\x1B[0m`);
+    }
+    process.exitCode = 1;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
+  return `${(bytes / k ** i).toFixed(i === 0 ? 0 : 1)} ${sizes[i]}`;
+}
+function dirSize(root) {
+  let total = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (dir === void 0) continue;
+    for (const name of fs3.readdirSync(dir)) {
+      const absolute = path3.join(dir, name);
+      const stat = fs3.statSync(absolute);
+      if (stat.isDirectory()) {
+        stack.push(absolute);
+      } else {
+        total += stat.size;
+      }
+    }
+  }
+  return total;
+}
+function countAgentsInRun(runDir) {
+  const logsDir = path3.join(runDir, "logs");
+  if (!fs3.existsSync(logsDir)) return 0;
+  const reportPath = path3.join(logsDir, "report.json");
+  if (!fs3.existsSync(reportPath)) {
+    return fs3.readdirSync(logsDir).filter((n) => n.endsWith(".log")).length;
+  }
+  try {
+    const raw = fs3.readFileSync(reportPath, "utf-8");
+    const report = JSON.parse(raw);
+    return report.agentResults?.length ?? 0;
+  } catch {
+    return fs3.readdirSync(logsDir).filter((n) => n.endsWith(".log")).length;
+  }
+}
+
 // src/commands/run.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 import {
   describeResumePlan,
   Orchestrator as OrchestratorImpl
@@ -669,8 +877,8 @@ ${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
 };
 
 // src/reporters/FileLogWriter.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var FileLogWriter = class {
   constructor(logDir, onError = (message) => process.stderr.write(`
 [multiclaw] ${message}
@@ -681,7 +889,7 @@ var FileLogWriter = class {
     /** Agent ids whose log could not be opened — never retried, so a broken
      *  directory does not produce one failing stream per output chunk. */
     this.failed = /* @__PURE__ */ new Set();
-    fs3.mkdirSync(logDir, { recursive: true });
+    fs4.mkdirSync(logDir, { recursive: true });
   }
   attach(eventBus) {
     return eventBus.subscribe((e) => this.handle(e));
@@ -705,7 +913,7 @@ var FileLogWriter = class {
     }
     if (e.type === "orchestration:complete") {
       try {
-        fs3.writeFileSync(path3.join(this.logDir, "report.json"), JSON.stringify(e.payload, null, 2));
+        fs4.writeFileSync(path4.join(this.logDir, "report.json"), JSON.stringify(e.payload, null, 2));
       } catch (err) {
         this.onError(`Could not write report.json: ${errorMessage(err)}`);
       }
@@ -716,7 +924,7 @@ var FileLogWriter = class {
     if (this.failed.has(agentId)) return void 0;
     let stream = this.streams.get(agentId);
     if (!stream) {
-      stream = fs3.createWriteStream(path3.join(this.logDir, `${agentId}.log`));
+      stream = fs4.createWriteStream(path4.join(this.logDir, `${agentId}.log`));
       stream.on("error", (err) => {
         this.failed.add(agentId);
         this.streams.delete(agentId);
@@ -747,32 +955,32 @@ function errorMessage(err) {
 }
 
 // src/commands/resume.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function resolveRunDir(runsRoot, target) {
   if (typeof target !== "string" || target === "latest") {
     return latestRunDir(runsRoot);
   }
-  const resolved = path4.resolve(target);
-  const runDir = path4.basename(resolved) === "logs" ? path4.dirname(resolved) : resolved;
-  if (!fs4.existsSync(runDir)) {
+  const resolved = path5.resolve(target);
+  const runDir = path5.basename(resolved) === "logs" ? path5.dirname(resolved) : resolved;
+  if (!fs5.existsSync(runDir)) {
     throw new Error(`Run directory not found: ${runDir}`);
   }
   return runDir;
 }
 function latestRunDir(runsRoot) {
-  const names = fs4.existsSync(runsRoot) ? fs4.readdirSync(runsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("run-")).map((entry) => entry.name).sort() : [];
+  const names = fs5.existsSync(runsRoot) ? fs5.readdirSync(runsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("run-")).map((entry) => entry.name).sort() : [];
   const latest = names[names.length - 1];
   if (!latest) {
     throw new Error(`No runs found to resume \u2014 looked in ${runsRoot}`);
   }
-  return path4.join(runsRoot, latest);
+  return path5.join(runsRoot, latest);
 }
 function readReport(runDir) {
-  const reportPath = path4.join(runDir, "logs", "report.json");
+  const reportPath = path5.join(runDir, "logs", "report.json");
   let raw;
   try {
-    raw = fs4.readFileSync(reportPath, "utf-8");
+    raw = fs5.readFileSync(reportPath, "utf-8");
   } catch {
     throw new Error(`No report.json in ${runDir} \u2014 it may not be a complete run`);
   }
@@ -817,14 +1025,14 @@ async function runCommand(requirementArg, options) {
   }
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
   if (options.resume !== void 0) {
-    const runsRoot = path5.join(config.workDir, ".multiclaw", "runs");
+    const runsRoot = path6.join(config.workDir, ".multiclaw", "runs");
     const runDir = resolveRunDir(runsRoot, options.resume);
     const report = readReport(runDir);
     const { requirement, resume } = resumeOptionsFromReport(report, requirementArg);
     config.workDir = runDir;
     config.resume = resume;
     config.context = { ...config.context, requirement };
-    config.logDir = path5.join(runDir, `logs-resume-${stamp}`);
+    config.logDir = path6.join(runDir, `logs-resume-${stamp}`);
     const plan = describeResumePlan({
       agents: resume.agents,
       sessions: resume.sessions,
@@ -832,7 +1040,7 @@ async function runCommand(requirementArg, options) {
     });
     console.log(`\x1B[2mResuming ${runDir} (${resume.agents.length} agents) \u2014 ${plan}\x1B[0m`);
   } else {
-    config.workDir = path5.join(config.workDir, ".multiclaw", "runs", `run-${stamp}`);
+    config.workDir = path6.join(config.workDir, ".multiclaw", "runs", `run-${stamp}`);
   }
   if (options.dryRun) {
     const preview = await new OrchestratorImpl(config).preview();
@@ -848,7 +1056,7 @@ async function runCommand(requirementArg, options) {
     event.payload.deliverables = collectDeliverables(config.workDir, before);
   });
   new ConsoleReporter().attach(orchestrator.eventBus);
-  const logDir = config.logDir ?? path5.join(config.workDir, "logs");
+  const logDir = config.logDir ?? path6.join(config.workDir, "logs");
   const logs = new FileLogWriter(logDir);
   logs.attach(orchestrator.eventBus);
   console.log(`\x1B[2mLogs: ${logDir}\x1B[0m`);
@@ -906,16 +1114,16 @@ function collectDeliverables(root, before) {
   return deliverables.sort((a, b) => a.path.localeCompare(b.path)).slice(0, 20);
 }
 function walkFiles(root, visit) {
-  if (!fs5.existsSync(root)) return;
+  if (!fs6.existsSync(root)) return;
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
-    for (const name of fs5.readdirSync(dir)) {
+    for (const name of fs6.readdirSync(dir)) {
       if (name === ".multiclaw") continue;
-      const absolute = path5.join(dir, name);
-      const stat = fs5.statSync(absolute);
+      const absolute = path6.join(dir, name);
+      const stat = fs6.statSync(absolute);
       if (stat.isDirectory()) stack.push(absolute);
-      else if (stat.isFile()) visit(absolute, path5.relative(root, absolute), stat);
+      else if (stat.isFile()) visit(absolute, path6.relative(root, absolute), stat);
     }
   }
 }
@@ -943,18 +1151,18 @@ async function tuiCommand(options) {
 
 // src/commands/upgrade.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join5, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "multiclaw";
 var RED2 = "\x1B[31m";
 var GREEN2 = "\x1B[32m";
 var RESET2 = "\x1B[0m";
 function readManifest(dir) {
-  const manifest = join4(dir, "package.json");
-  if (!existsSync5(manifest)) return void 0;
+  const manifest = join5(dir, "package.json");
+  if (!existsSync6(manifest)) return void 0;
   try {
-    return JSON.parse(readFileSync2(manifest, "utf8"));
+    return JSON.parse(readFileSync3(manifest, "utf8"));
   } catch {
     return void 0;
   }
@@ -972,11 +1180,11 @@ function readInstalledVersion(pkgRoot) {
   return readManifest(pkgRoot)?.version;
 }
 function detectInstaller(pkgRoot) {
-  const path6 = pkgRoot.replaceAll("\\", "/");
-  if (path6.includes("/pnpm/global/") || path6.includes("/.pnpm/")) return "pnpm";
-  if (path6.includes("/install/global/") || path6.includes("/.bun/")) return "bun";
-  if (path6.includes("/yarn/global/")) return "yarn";
-  if (path6.includes("/node_modules/")) return "npm";
+  const path7 = pkgRoot.replaceAll("\\", "/");
+  if (path7.includes("/pnpm/global/") || path7.includes("/.pnpm/")) return "pnpm";
+  if (path7.includes("/install/global/") || path7.includes("/.bun/")) return "bun";
+  if (path7.includes("/yarn/global/")) return "yarn";
+  if (path7.includes("/node_modules/")) return "npm";
   return "unknown";
 }
 var COMMANDS = {
@@ -1068,7 +1276,7 @@ async function upgradeCommand() {
 // src/index.ts
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname4(__filename2);
-var pkg = JSON.parse(readFileSync3(join5(__dirname2, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync4(join6(__dirname2, "../package.json"), "utf-8"));
 var program = new Command();
 program.name("multiclaw").description("Multi-agent orchestration CLI").version(pkg.version, "-v, --version", "Display version number").action((options) => tuiCommand(options));
 program.command("init").description("Scaffold a config file (interactive)").action(() => initCommand());
@@ -1078,6 +1286,7 @@ program.command("run [requirement]").description("Run an orchestration headlessl
 ).action((requirement, opts) => runCommand(requirement, opts));
 program.command("upgrade").description("Upgrade multiclaw to the latest version").action(() => upgradeCommand());
 program.command("doctor").description("Check which agent providers are installed and ready").option("--config <path>", "Config file path (default: auto-discover ./multiclaw.config.ts)").action((opts) => doctorCommand(opts.config));
+program.command("prune").description("Clean up history entries and old run directories (interactive)").option("--config <path>", "Config file path (default: auto-discover ./multiclaw.config.ts)").option("--history", "Prune console history only (non-interactive)").option("--runs", "Prune all runs only (non-interactive)").option("--all", "Prune everything (non-interactive)").option("--dry-run", "Show what would be deleted without deleting").option("--yes", "Skip confirmation prompt").action((opts) => pruneCommand(opts));
 program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
   console.error(`\x1B[31mError: ${message}\x1B[0m`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiclaw",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "type": "module",
   "bin": {
     "multiclaw": "dist/index.js"
@@ -30,8 +30,8 @@
     "@agentclientprotocol/claude-agent-acp": "^0.95.0",
     "@agentclientprotocol/codex-acp": "^2.2.2",
     "@inquirer/prompts": "^8.7.4",
-    "@multiclawcli/core": "0.7.0",
-    "@multiclawcli/dashboard": "0.7.0",
+    "@multiclawcli/core": "0.8.1",
+    "@multiclawcli/dashboard": "0.8.1",
     "commander": "^15.0.0",
     "jiti": "^2.7.0"
   },