@caddis/cli 0.1.0 → 0.2.0

package/dist/cli.js

@@ -4425,7 +4425,10 @@ async function driveAgents(entries, options) {
     const label = `${entry.adapter.name}`;
     const spinner = useSpinner ? Y2() : null;
     spinner?.start(`${label} \u2014 ${entry.adapter.summary}`);
-    const result = await entry.adapter.drive(options.action, { dryRun: options.dryRun });
+    const result = await entry.adapter.drive(options.action, {
+      dryRun: options.dryRun,
+      extras: options.extras === true
+    });
     if (result.skipped) {
       outcome.skipped += 1;
       spinner?.stop(`${label} \u2014 ${result.message ?? "skipped"}`, 0);
@@ -4489,20 +4492,38 @@ function classify(adapter, detection, status4, poolVersion) {
   return status4.version === poolVersion ? "current" : "stale";
 }
 async function gather(adapters) {
-  const { poolVersion } = bundleManifest();
+  const manifest = bundleManifest();
+  const poolVersion = manifest.poolVersion;
+  const extrasVersion = manifest.bundles["antigravity-plugin-extras"];
   const agents = await Promise.all(
     adapters.map(async (adapter) => {
       const detection = await adapter.detect();
       const status4 = detection.present ? await adapter.status() : { installed: false, note: "agent not installed" };
-      return { adapter, detection, status: status4, drift: classify(adapter, detection, status4, poolVersion) };
+      return {
+        adapter,
+        detection,
+        status: status4,
+        drift: classify(adapter, detection, status4, poolVersion),
+        extrasDrift: classifyExtras(adapter, detection, status4, extrasVersion)
+      };
     })
   );
-  return { cliVersion: packageInfo().version, poolVersion, agents };
+  return { cliVersion: packageInfo().version, poolVersion, extrasVersion, agents };
+}
+function classifyExtras(adapter, detection, status4, extrasVersion) {
+  if (!status4.extras) return void 0;
+  if (!detection.present) return "absent";
+  if (!adapter.supported) return "unsupported";
+  if (!status4.extras.installed) return "missing";
+  if (!status4.extras.version || !extrasVersion) return "unknown";
+  return status4.extras.version === extrasVersion ? "current" : "stale";
 }
 function actionable(report, includeCurrent = false) {
-  return report.agents.filter(
-    (entry) => entry.detection.present && entry.adapter.supported && (includeCurrent || entry.drift !== "current")
-  );
+  return report.agents.filter((entry) => {
+    if (!entry.detection.present || !entry.adapter.supported) return false;
+    if (includeCurrent) return true;
+    return entry.drift !== "current" || entry.extrasDrift === "stale" || entry.extrasDrift === "unknown";
+  });
 }
 var init_report = __esm({
   "src/commands/report.ts"() {
@@ -4555,7 +4576,12 @@ async function init(options) {
       return 0;
     }
   }
-  const outcome = await driveAgents(targets, { action: "install", dryRun: options.dryRun, quiet: options.yes });
+  const outcome = await driveAgents(targets, {
+    action: "install",
+    dryRun: options.dryRun,
+    extras: options.extras,
+    quiet: options.yes
+  });
   const code = reportOutcome(outcome, options.dryRun);
   Se(code === 0 ? `Run ${color.cyan("caddis doctor")} any time to check drift.` : "Finished with errors.");
   return code;
@@ -4595,7 +4621,12 @@ async function update(options) {
     return 0;
   }
   line("");
-  const outcome = await driveAgents(targets, { action: "update", dryRun: options.dryRun, quiet: options.yes });
+  const outcome = await driveAgents(targets, {
+    action: "update",
+    dryRun: options.dryRun,
+    extras: options.extras,
+    quiet: options.yes
+  });
   return reportOutcome(outcome, options.dryRun);
 }
 var init_update = __esm({
@@ -4647,6 +4678,9 @@ function renderEnvironment(report, problems) {
     for (const [name, version] of Object.entries(manifest.bundles)) {
       detail(`bundle ${name} @ ${version}`);
     }
+    if (report.extrasVersion) {
+      detail(`caddis-extras ships at ${report.extrasVersion} (versioned independently of the pool)`);
+    }
   }
 }
 function renderAgents(report, problems) {
@@ -4659,11 +4693,17 @@ function renderAgents(report, problems) {
     if (status4.source) detail(`read from ${status4.source}`);
     if (status4.note) detail(status4.note);
     if (detection.note && detection.note !== status4.note) detail(detection.note);
+    if (entry.extrasDrift) detail(describeExtras(entry, report.extrasVersion));
     const problem = problemFor(entry, report.poolVersion);
     if (problem) {
       problems.push(problem);
       if (problem.fix) hint(color.bold(problem.fix));
     }
+    const extrasProblem = extrasProblemFor(entry, report.extrasVersion);
+    if (extrasProblem) {
+      problems.push(extrasProblem);
+      if (extrasProblem.fix) hint(color.bold(extrasProblem.fix));
+    }
   }
 }
 function renderSummary(report, findings) {
@@ -4725,6 +4765,38 @@ function describe(entry, poolVersion) {
       return color.dim("not installed on this machine");
   }
 }
+function describeExtras(entry, extrasVersion) {
+  const installed = entry.status.extras?.version;
+  switch (entry.extrasDrift) {
+    case "current":
+      return `caddis-extras ${installed} (current)`;
+    case "stale":
+      return `caddis-extras ${installed} \u2192 ${extrasVersion ?? "?"} available`;
+    case "unknown":
+      return "caddis-extras installed, version not reported";
+    case "missing":
+      return `caddis-extras not installed (optional \u2014 add with --extras)`;
+    default:
+      return "caddis-extras n/a";
+  }
+}
+function extrasProblemFor(entry, extrasVersion) {
+  if (entry.extrasDrift === "stale") {
+    return {
+      kind: "problem",
+      text: `${entry.adapter.name} has caddis-extras ${entry.status.extras?.version}, this CLI ships ${extrasVersion}`,
+      fix: `caddis update --agent ${entry.adapter.id}`
+    };
+  }
+  if (entry.extrasDrift === "unknown") {
+    return {
+      kind: "problem",
+      text: `${entry.adapter.name} has caddis-extras but will not report a version`,
+      fix: `caddis update --agent ${entry.adapter.id} --extras`
+    };
+  }
+  return null;
+}
 function problemFor(entry, poolVersion) {
   const scope = `--agent ${entry.adapter.id}`;
   switch (entry.drift) {
@@ -4766,6 +4838,7 @@ function toJson(report) {
   return {
     cliVersion: report.cliVersion,
     poolVersion: report.poolVersion,
+    extrasVersion: report.extrasVersion ?? null,
     node: process2.versions.node,
     platform: `${process2.platform}-${process2.arch}`,
     agents: report.agents.map((entry) => ({
@@ -4778,6 +4851,8 @@ function toJson(report) {
       caddisVersion: entry.status.version ?? null,
       disabled: entry.status.disabled ?? false,
       drift: entry.drift,
+      extrasVersion: entry.status.extras?.version ?? null,
+      extrasDrift: entry.extrasDrift ?? null,
       note: entry.status.note ?? entry.detection.note ?? null
     }))
   };
@@ -4834,11 +4909,15 @@ async function status3(options) {
     return 0;
   }
   line("");
-  line(`  ${color.bold("caddis")}  cli ${color.bold(report.cliVersion)}  \xB7  pool ${color.bold(report.poolVersion)}`);
+  line(
+    `  ${color.bold("caddis")}  cli ${color.bold(report.cliVersion)}  \xB7  pool ${color.bold(report.poolVersion)}` + (report.extrasVersion ? `  \xB7  extras ${color.bold(report.extrasVersion)}` : "")
+  );
   line("");
-  line(renderTable(["AGENT", "DETECTED", "CADDIS", "STATE"], report.agents.map(toRow)));
+  line(renderTable(["AGENT", "DETECTED", "CADDIS", "EXTRAS", "STATE"], report.agents.map(toRow)));
   line("");
-  const stale = report.agents.filter((entry) => entry.drift === "stale" || entry.drift === "missing");
+  const stale = report.agents.filter(
+    (entry) => entry.drift === "stale" || entry.drift === "missing" || entry.extrasDrift === "stale"
+  );
   if (stale.length > 0) {
     line(`  ${color.yellow(`${stale.length} agent(s) behind`)} \u2014 run ${color.cyan("caddis update")} (or ${color.cyan("caddis doctor")} for detail)`);
     line("");
@@ -4851,6 +4930,9 @@ function toRow(entry) {
     entry.adapter.name,
     entry.detection.present ? color.green("yes") : color.dim("no"),
     managed && entry.status.version || color.dim("\u2014"),
+    // Extras gets its own column rather than being folded into CADDIS: it
+    // versions independently, so showing one number for both would be a lie.
+    managed && entry.status.extras?.version || color.dim("\u2014"),
     stateLabel(entry.drift, entry.status.disabled ?? false)
   ];
 }
@@ -5092,8 +5174,10 @@ init_pkg();
 var BIN2 = "agy";
 var BUNDLE = "antigravity-plugin";
 var PLUGIN2 = "caddis";
-function pluginManifestPath(home = os.homedir()) {
-  return path2.join(home, ".gemini", "config", "plugins", PLUGIN2, "plugin.json");
+var EXTRAS_BUNDLE = "antigravity-plugin-extras";
+var EXTRAS_PLUGIN = "caddis-extras";
+function pluginManifestPath(home = os.homedir(), plugin = PLUGIN2) {
+  return path2.join(home, ".gemini", "config", "plugins", plugin, "plugin.json");
 }
 async function detect2() {
   const binPath = await findBin(BIN2);
@@ -5120,17 +5204,31 @@ function readInstalledVersion(manifestFile) {
 function statusFromHome(home) {
   const manifestFile = pluginManifestPath(home);
   const version = readInstalledVersion(manifestFile);
+  const extras = extrasStatusFromHome(home);
   if (version) {
-    return { installed: true, version, source: shortenHome(manifestFile) };
+    return { installed: true, version, source: shortenHome(manifestFile), extras };
   }
   if (existsSync2(manifestFile)) {
     return {
       installed: true,
       source: shortenHome(manifestFile),
+      extras,
       note: "manifest present but unreadable / has no version"
     };
   }
-  return { installed: false, source: shortenHome(manifestFile), note: "caddis plugin not imported into agy" };
+  return {
+    installed: false,
+    source: shortenHome(manifestFile),
+    extras,
+    note: "caddis plugin not imported into agy"
+  };
+}
+function extrasStatusFromHome(home) {
+  const manifestFile = pluginManifestPath(home, EXTRAS_PLUGIN);
+  const version = readInstalledVersion(manifestFile);
+  if (version) return { installed: true, version, source: shortenHome(manifestFile) };
+  if (existsSync2(manifestFile)) return { installed: true, source: shortenHome(manifestFile) };
+  return { installed: false };
 }
 async function status2() {
   const detected = await detect2();
@@ -5155,30 +5253,50 @@ async function drive2(_action, options) {
       message: `the ${BUNDLE} bundle is missing from this package \u2014 reinstall @caddis/cli`
     };
   }
-  const step = { cmd: BIN2, args: ["plugin", "install", bundle] };
-  const command = formatCommand(step.cmd, step.args);
+  const planned = [{ cmd: BIN2, args: ["plugin", "install", bundle] }];
+  const extrasInstalled = extrasStatusFromHome(os.homedir()).installed;
+  if (options.extras === true || extrasInstalled) {
+    const extrasBundle = bundlePath(EXTRAS_BUNDLE);
+    if (extrasBundle) {
+      planned.push({ cmd: BIN2, args: ["plugin", "install", extrasBundle] });
+    } else if (options.extras === true) {
+      return {
+        ok: false,
+        skipped: false,
+        steps: [],
+        message: `--extras requested but the ${EXTRAS_BUNDLE} bundle is missing from this package \u2014 reinstall @caddis/cli`
+      };
+    }
+  }
   if (options.dryRun) {
-    return { ok: true, skipped: true, steps: [{ command, ok: true, code: null }], message: "dry run \u2014 nothing executed" };
+    return {
+      ok: true,
+      skipped: true,
+      steps: planned.map((s) => ({ command: formatCommand(s.cmd, s.args), ok: true, code: null })),
+      message: "dry run \u2014 nothing executed"
+    };
   }
-  const result = await run(step.cmd, step.args);
-  const stepResult = {
-    command,
-    ok: result.ok,
-    code: result.code,
-    output: result.ok ? void 0 : (result.stderr || result.stdout || result.failure || "").trim().split(/\r?\n/).slice(-3).join("\n")
-  };
-  return {
-    ok: result.ok,
-    skipped: false,
-    steps: [stepResult],
-    message: result.ok ? void 0 : `\`${command}\` failed`
-  };
+  const steps2 = [];
+  for (const step of planned) {
+    const command = formatCommand(step.cmd, step.args);
+    const result = await run(step.cmd, step.args);
+    steps2.push({
+      command,
+      ok: result.ok,
+      code: result.code,
+      output: result.ok ? void 0 : (result.stderr || result.stdout || result.failure || "").trim().split(/\r?\n/).slice(-3).join("\n")
+    });
+    if (!result.ok) {
+      return { ok: false, skipped: false, steps: steps2, message: `\`${command}\` failed` };
+    }
+  }
+  return { ok: true, skipped: false, steps: steps2 };
 }
 var agyAdapter = {
   id: "agy",
   name: "agy (Antigravity)",
   supported: true,
-  summary: "install the caddis bundle shipped in this package",
+  summary: "install the caddis bundle shipped in this package (--extras adds caddis-extras)",
   detect: detect2,
   drive: drive2,
   status: status2
@@ -5281,12 +5399,19 @@ function mergeFlags(local) {
 withGlobalFlags(program2).name("caddis").description(
   "Install, update and diagnose the caddis dev harness across every coding agent you use.\ncaddis drives each agent's OWN installer \u2014 it never replaces them."
 ).version(pkg.version, "-v, --version", "print the CLI version").showHelpAfterError();
-withGlobalFlags(program2.command("init")).description("first run: detect your agents, confirm, install caddis into each").action(async (options) => {
+withGlobalFlags(program2.command("init")).description("first run: detect your agents, confirm, install caddis into each").option("--extras", "also install the optional caddis-extras long-tail skills", false).action(async (options) => {
   const flags = mergeFlags(options);
   const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  finish(await init2({ adapters: resolveAdapters(flags), dryRun: flags.dryRun, yes: flags.yes }));
+  finish(
+    await init2({
+      adapters: resolveAdapters(flags),
+      dryRun: flags.dryRun,
+      yes: flags.yes,
+      extras: options.extras === true
+    })
+  );
 });
-withGlobalFlags(program2.command("update")).description("update every detected agent to the caddis version shipped in this CLI").option("-f, --force", "re-drive agents that already report the shipped version", false).action(async (options) => {
+withGlobalFlags(program2.command("update")).description("update every detected agent to the caddis version shipped in this CLI").option("-f, --force", "re-drive agents that already report the shipped version", false).option("--extras", "also install the optional caddis-extras long-tail skills", false).action(async (options) => {
   const flags = mergeFlags(options);
   const { update: update2 } = await Promise.resolve().then(() => (init_update(), update_exports));
   finish(
@@ -5294,7 +5419,8 @@ withGlobalFlags(program2.command("update")).description("update every detected a
       adapters: resolveAdapters(flags),
       dryRun: flags.dryRun,
       yes: flags.yes,
-      force: options.force === true
+      force: options.force === true,
+      extras: options.extras === true
     })
   );
 });
@@ -5316,11 +5442,14 @@ ${color.bold("Examples")}
   $ caddis doctor                   what is installed where, and what to do about it
   $ caddis update --dry-run         preview the exact vendor commands
   $ caddis update --agent agy       update just one agent
+  $ caddis init --extras            add the optional caddis-extras skill library
   $ caddis doctor --strict          exit non-zero on drift (CI)
 
 ${color.bold("Supported agents")}
   claude    Claude Code       via its plugin marketplace
   agy       Antigravity       via the caddis bundle shipped in this package
+                              (--extras adds caddis-extras; already-installed
+                               extras is kept current automatically)
   codex     Codex             detected only \u2014 config merge lands in v0.2
   copilot   GitHub Copilot    detected only \u2014 config merge lands in v0.2
 `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caddis/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Install, update and diagnose the caddis dev harness across every coding agent you use (Claude Code, agy/Antigravity, and more).",
   "keywords": [
     "caddis",