docks-kit 0.17.1 → 0.17.2

package/cli/src/commands/status.ts

@@ -1,32 +1,32 @@
-import { Command, Flag } from "effect/unstable/cli"
-import { Console, Effect } from "effect"
-import { engineCapture, type EngineCaptureError } from "../engine"
+import { Command, Flag } from "effect/unstable/cli";
+import { Console, Effect } from "effect";
+import { engineCapture, type EngineCaptureError } from "../engine";
 import {
   deployedClaudeSettings,
   deployedCodexModel,
   pluginsView,
   skillsView,
   sotClaudeSettings,
-  sotCodexModel
-} from "../manifests"
-import { kitHome } from "../kitHome"
+  sotCodexModel,
+} from "../manifests";
+import { kitHome } from "../kitHome";
 
 const json = Flag.Boolean("json").pipe(
   Flag.withDescription("Machine-readable output"),
-  Flag.withDefault(false)
-)
+  Flag.withDefault(false),
+);
 
 interface Drift {
-  readonly setting: string
-  readonly deployed: string
-  readonly sot: string
-  readonly drifted: boolean
+  readonly setting: string;
+  readonly deployed: string;
+  readonly sot: string;
+  readonly drifted: boolean;
 }
 
 type ClaudeDeployment =
   | { readonly state: "absent" }
   | { readonly state: "valid"; readonly settings: Record<string, unknown> }
-  | { readonly state: "malformed"; readonly diagnostic: string }
+  | { readonly state: "malformed"; readonly diagnostic: string };
 
 const captureToolchainStatus = () =>
   engineCapture(["toolchain", "check"]).pipe(
@@ -36,58 +36,63 @@ const captureToolchainStatus = () =>
         state: "failed" as const,
         table: "",
         diagnostic: error.diagnostic,
-        exitCode: error.code
-      })
-    )
-  )
+        exitCode: error.code,
+      }),
+    ),
+  );
 
 const readClaudeDeployment = (): ClaudeDeployment => {
   try {
-    const settings: unknown = deployedClaudeSettings()
-    if (settings === undefined) return { state: "absent" }
+    const settings: unknown = deployedClaudeSettings();
+    if (settings === undefined) return { state: "absent" };
     if (settings === null || typeof settings !== "object" || Array.isArray(settings)) {
       return {
         state: "malformed",
-        diagnostic: "deployed Claude settings must contain a JSON object"
-      }
+        diagnostic: "deployed Claude settings must contain a JSON object",
+      };
     }
-    return { state: "valid", settings: settings as Record<string, unknown> }
+    return { state: "valid", settings: settings as Record<string, unknown> };
   } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error)
+    const detail = error instanceof Error ? error.message : String(error);
     return {
       state: "malformed",
-      diagnostic: `deployed Claude settings contain invalid JSON: ${detail}`
-    }
+      diagnostic: `deployed Claude settings contain invalid JSON: ${detail}`,
+    };
   }
-}
+};
 
 const gatherDrift = (): {
-  readonly drift: Array<Drift>
-  readonly claudeDeployment: ClaudeDeployment
+  readonly drift: Array<Drift>;
+  readonly claudeDeployment: ClaudeDeployment;
 } => {
-  const sot = sotClaudeSettings()
-  const claudeDeployment = readClaudeDeployment()
+  const sot = sotClaudeSettings();
+  const claudeDeployment = readClaudeDeployment();
   const row = (setting: string, deployed: unknown, sotVal: unknown): Drift => {
-    const d = String(deployed ?? "(unset)")
-    const s = String(sotVal ?? "(unset)")
-    return { setting, deployed: d, sot: s, drifted: d !== s }
-  }
-  const codex = row("codex.model", deployedCodexModel(), sotCodexModel())
+    const d = String(deployed ?? "(unset)");
+    const s = String(sotVal ?? "(unset)");
+    return { setting, deployed: d, sot: s, drifted: d !== s };
+  };
+  const codex = row("codex.model", deployedCodexModel(), sotCodexModel());
   if (claudeDeployment.state !== "valid") {
     return {
       claudeDeployment,
       drift: [
-        { setting: "claude.settings", deployed: `(${claudeDeployment.state})`, sot: "present", drifted: true },
-        codex
-      ]
-    }
+        {
+          setting: "claude.settings",
+          deployed: `(${claudeDeployment.state})`,
+          sot: "present",
+          drifted: true,
+        },
+        codex,
+      ],
+    };
   }
 
-  const dep = claudeDeployment.settings
+  const dep = claudeDeployment.settings;
   const env =
     dep.env !== null && typeof dep.env === "object" && !Array.isArray(dep.env)
       ? (dep.env as Record<string, unknown>)
-      : {}
+      : {};
   return {
     claudeDeployment,
     drift: [
@@ -96,40 +101,40 @@ const gatherDrift = (): {
       row(
         "claude.compactWindow",
         env.CLAUDE_CODE_AUTO_COMPACT_WINDOW,
-        sot.env?.CLAUDE_CODE_AUTO_COMPACT_WINDOW
+        sot.env?.CLAUDE_CODE_AUTO_COMPACT_WINDOW,
       ),
-      codex
-    ]
-  }
-}
+      codex,
+    ],
+  };
+};
 
 export const statusCommand = Command.make("status", { json }, (config) =>
   Effect.gen(function* () {
-    const { drift, claudeDeployment } = gatherDrift()
-    const plugins = pluginsView()
-    const skills = skillsView()
-    const toolchain = yield* captureToolchainStatus()
-    const diagnostics = new Array<{ source: string; message: string; exitCode: number }>()
+    const { drift, claudeDeployment } = gatherDrift();
+    const plugins = pluginsView();
+    const skills = skillsView();
+    const toolchain = yield* captureToolchainStatus();
+    const diagnostics = new Array<{ source: string; message: string; exitCode: number }>();
     if (claudeDeployment.state === "malformed") {
       diagnostics.push({
         source: "claude.settings",
         message: claudeDeployment.diagnostic,
-        exitCode: 1
-      })
+        exitCode: 1,
+      });
     }
     if (toolchain.state === "failed") {
       diagnostics.push({
         source: "toolchain",
         message: toolchain.diagnostic ?? "toolchain capture failed",
-        exitCode: toolchain.exitCode ?? 1
-      })
+        exitCode: toolchain.exitCode ?? 1,
+      });
     }
 
     if (config.json) {
       const deployment =
         claudeDeployment.state === "malformed"
           ? { claude: { state: claudeDeployment.state, diagnostic: claudeDeployment.diagnostic } }
-          : { claude: { state: claudeDeployment.state } }
+          : { claude: { state: claudeDeployment.state } };
       yield* Console.log(
         JSON.stringify(
           {
@@ -139,46 +144,48 @@ export const statusCommand = Command.make("status", { json }, (config) =>
             plugins,
             skills,
             toolchain,
-            diagnostics
+            diagnostics,
           },
           null,
-          2
-        )
-      )
+          2,
+        ),
+      );
     } else {
-      yield* Console.log(`Kit home: ${kitHome()}\n`)
-      yield* Console.log("Deployed vs SoT (drift is expected for deploy-time modifiers):")
+      yield* Console.log(`Kit home: ${kitHome()}\n`);
+      yield* Console.log("Deployed vs SoT (drift is expected for deploy-time modifiers):");
       for (const d of drift) {
-        const mark = d.drifted ? "≠" : "="
-        yield* Console.log(`  ${d.setting.padEnd(22)} deployed=${d.deployed}  ${mark}  SoT=${d.sot}`)
+        const mark = d.drifted ? "≠" : "=";
+        yield* Console.log(
+          `  ${d.setting.padEnd(22)} deployed=${d.deployed}  ${mark}  SoT=${d.sot}`,
+        );
       }
       if (claudeDeployment.state === "malformed") {
-        yield* Console.log(`  ERROR claude.settings: ${claudeDeployment.diagnostic}`)
+        yield* Console.log(`  ERROR claude.settings: ${claudeDeployment.diagnostic}`);
       }
-      yield* Console.log("\nToolchain:")
+      yield* Console.log("\nToolchain:");
       if (toolchain.state === "failed") {
-        yield* Console.log(`  ERROR: ${toolchain.diagnostic}`)
+        yield* Console.log(`  ERROR: ${toolchain.diagnostic}`);
       } else {
-        yield* Console.log(toolchain.table.trimEnd())
+        yield* Console.log(toolchain.table.trimEnd());
       }
-      const enabled = plugins.filter((p) => p.sot === "true").length
+      const enabled = plugins.filter((p) => p.sot === "true").length;
       yield* Console.log(
-        `\nPlugins: ${plugins.length} known (${enabled} SoT-enabled) — details: docks-kit plugins list`
-      )
-      const installed = skills.filter((s) => s.installed).length
+        `\nPlugins: ${plugins.length} known (${enabled} SoT-enabled) — details: docks-kit plugins list`,
+      );
+      const installed = skills.filter((s) => s.installed).length;
       yield* Console.log(
-        `Skills:  ${skills.length} known (${installed} installed) — details: docks-kit skills list`
-      )
+        `Skills:  ${skills.length} known (${installed} installed) — details: docks-kit skills list`,
+      );
     }
 
     if (diagnostics.length > 0) {
       yield* Effect.sync(() => {
-        process.exitCode = diagnostics[0]?.exitCode ?? 1
-      })
+        process.exitCode = diagnostics[0]?.exitCode ?? 1;
+      });
     }
-  })
+  }),
 ).pipe(
   Command.withDescription(
-    "Doctor view: deployed-vs-SoT drift, toolchain, and plugin/skill counts."
-  )
-)
+    "Doctor view: deployed-vs-SoT drift, toolchain, and plugin/skill counts.",
+  ),
+);

package/cli/src/commands/sync.ts

@@ -1,100 +1,126 @@
-import { Argument, Command, Flag } from "effect/unstable/cli"
-import { Effect, Option } from "effect"
-import { spawnSync } from "node:child_process"
-import { existsSync } from "node:fs"
-import { join } from "node:path"
-import { bail, engine } from "../engine"
-import type { Logger } from "../engine-native/logger"
-import { kitHome } from "../kitHome"
-import { LoggerService } from "../services"
+import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Effect, Option } from "effect";
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { bail, engine } from "../engine";
+import type { Logger } from "../engine-native/logger";
+import { kitHome } from "../kitHome";
+import { LoggerService } from "../services";
 
 /** Best-effort update autodetection: nudge (never block, never fail) when
  * the kit checkout is behind its upstream. Silent on detached HEADs, no
  * upstream, no network, no git. */
 const updateNudge = (logger: Logger): void => {
   try {
-    const home = kitHome()
-    if (!existsSync(join(home, ".git"))) return
-    if (spawnSync("git", ["-C", home, "fetch", "--quiet"], { stdio: "ignore", timeout: 4000 }).status !== 0) return
+    const home = kitHome();
+    if (!existsSync(join(home, ".git"))) return;
+    if (
+      spawnSync("git", ["-C", home, "fetch", "--quiet"], { stdio: "ignore", timeout: 4000 })
+        .status !== 0
+    )
+      return;
     const res = spawnSync("git", ["-C", home, "rev-list", "--count", "HEAD..@{u}"], {
       encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    })
-    const behind = (res.stdout ?? "").trim()
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    const behind = (res.stdout ?? "").trim();
     if (res.status === 0 && behind !== "" && behind !== "0") {
-      logger.warn(`kit checkout is ${behind} commit(s) behind its upstream — run: docks-kit update`)
+      logger.warn(
+        `kit checkout is ${behind} commit(s) behind its upstream — run: docks-kit update`,
+      );
     }
   } catch {
     // nudge only — a sync must never fail because the update check did
   }
-}
+};
 
-const VALID_TARGETS = ["claude", "codex", "agents", "omp"]
+const VALID_TARGETS = ["claude", "codex", "agents", "omp"];
 
 const targets: Argument.Argument<ReadonlyArray<string>> = Argument.String("target").pipe(
-  Argument.withDescription("Sync targets: claude, codex, agents, omp (default: selected harnesses)"),
-  Argument.variadic()
-)
+  Argument.withDescription(
+    "Sync targets: claude, codex, agents, omp (default: selected harnesses)",
+  ),
+  Argument.variadic(),
+);
 
 const dryRun = Flag.Boolean("dry-run").pipe(
   Flag.withDescription("Preview without applying"),
-  Flag.withDefault(false)
-)
+  Flag.withDefault(false),
+);
 const reconcile = Flag.Boolean("reconcile").pipe(
-  Flag.withDescription("Reconcile kit-owned settings with SoT (SoT keys win; user-only keys preserved; permissions arrays replaced)"),
-  Flag.withDefault(false)
-)
+  Flag.withDescription(
+    "Reconcile kit-owned settings with SoT (SoT keys win; user-only keys preserved; permissions arrays replaced)",
+  ),
+  Flag.withDefault(false),
+);
 const prune = Flag.Boolean("prune").pipe(
-  Flag.withDescription("Uninstall kit-managed installs not in SoT (plugins, marketplaces, universal skills)"),
-  Flag.withDefault(false)
-)
+  Flag.withDescription(
+    "Uninstall kit-managed installs not in SoT (plugins, marketplaces, universal skills)",
+  ),
+  Flag.withDefault(false),
+);
 const skipBubblewrap = Flag.Boolean("skip-bubblewrap").pipe(
   Flag.withDescription("Skip optional bubblewrap bootstrap (Codex Linux sandbox)"),
-  Flag.withDefault(false)
-)
+  Flag.withDefault(false),
+);
 const skipPluginRefresh = Flag.Boolean("skip-plugin-refresh").pipe(
-  Flag.withDescription("Install missing plugins but skip refresh-only updates for existing plugins"),
-  Flag.withDefault(false)
-)
+  Flag.withDescription(
+    "Install missing plugins but skip refresh-only updates for existing plugins",
+  ),
+  Flag.withDefault(false),
+);
 const verbose = Flag.Boolean("verbose").pipe(
   Flag.withAlias("v"),
   Flag.withDescription("Also print no-op confirmations (already in sync, up to date, left as-is)"),
-  Flag.withDefault(false)
-)
+  Flag.withDefault(false),
+);
 const claudeModel = Flag.String("claude-model").pipe(
-  Flag.withDescription("Deploy-time modifier: set deployed Claude model (see `docks-kit models claude`)"),
-  Flag.optional
-)
+  Flag.withDescription(
+    "Deploy-time modifier: set deployed Claude model (see `docks-kit models claude`)",
+  ),
+  Flag.optional,
+);
 const claudeEffort = Flag.String("claude-effort").pipe(
-  Flag.withDescription("Deploy-time modifier: set Claude effortLevel (bare flag shows valid levels)"),
-  Flag.optional
-)
+  Flag.withDescription(
+    "Deploy-time modifier: set Claude effortLevel (bare flag shows valid levels)",
+  ),
+  Flag.optional,
+);
 const claudeAdvisor = Flag.String("claude-advisor").pipe(
   Flag.withDescription("Deploy-time modifier: set Claude advisor on/off/default"),
-  Flag.optional
-)
+  Flag.optional,
+);
 const claudeCompactWindow = Flag.String("claude-compact-window").pipe(
-  Flag.withDescription("Deploy-time modifier: set deployed autocompact window in tokens (e.g. 680000 or 680k)"),
-  Flag.optional
-)
+  Flag.withDescription(
+    "Deploy-time modifier: set deployed autocompact window in tokens (e.g. 680000 or 680k)",
+  ),
+  Flag.optional,
+);
 const claudePermissive = Flag.Boolean("claude-permissive").pipe(
-  Flag.withDescription("Deploy-time modifier: empty permissions.ask/deny in deployed settings (sandboxes)"),
-  Flag.withDefault(false)
-)
+  Flag.withDescription(
+    "Deploy-time modifier: empty permissions.ask/deny in deployed settings (sandboxes)",
+  ),
+  Flag.withDefault(false),
+);
 const claudePlugin = Flag.String("claude-plugin").pipe(
   Flag.withDescription(
-    "Sticky opt-in plugin(s); repeatable and/or comma-separated (known: supabase, n8n)"
+    "Sticky opt-in plugin(s); repeatable and/or comma-separated (known: supabase, n8n)",
   ),
-  Flag.atLeast(0)
-)
+  Flag.atLeast(0),
+);
 const codexModel = Flag.String("codex-model").pipe(
-  Flag.withDescription("Deploy-time modifier: set deployed Codex model (see `docks-kit models codex`)"),
-  Flag.optional
-)
+  Flag.withDescription(
+    "Deploy-time modifier: set deployed Codex model (see `docks-kit models codex`)",
+  ),
+  Flag.optional,
+);
 const codexEffort = Flag.String("codex-effort").pipe(
-  Flag.withDescription("Deploy-time modifier: set Codex model_reasoning_effort (bare flag shows valid levels)"),
-  Flag.optional
-)
+  Flag.withDescription(
+    "Deploy-time modifier: set Codex model_reasoning_effort (bare flag shows valid levels)",
+  ),
+  Flag.optional,
+);
 
 export const syncCommand = Command.make(
   "sync",
@@ -113,53 +139,53 @@ export const syncCommand = Command.make(
     claudePermissive,
     claudePlugin,
     codexModel,
-    codexEffort
+    codexEffort,
   },
   (config) =>
     Effect.gen(function* () {
-      const bad = config.targets.filter((t) => !VALID_TARGETS.includes(t))
+      const bad = config.targets.filter((t) => !VALID_TARGETS.includes(t));
       if (bad.length > 0) {
         return yield* bail(
-          `Unknown sync target(s): ${bad.join(", ")} (valid: ${VALID_TARGETS.join(", ")})`
-        )
+          `Unknown sync target(s): ${bad.join(", ")} (valid: ${VALID_TARGETS.join(", ")})`,
+        );
       }
 
-      const args: Array<string> = ["sync", ...config.targets]
-      if (config.dryRun) args.push("--dry-run")
-      if (config.reconcile) args.push("--reconcile")
-      if (config.prune) args.push("--prune")
-      if (config.skipBubblewrap) args.push("--skip-bubblewrap")
-      if (config.skipPluginRefresh) args.push("--skip-plugin-refresh")
-      if (config.verbose) args.push("--verbose")
-      if (config.claudePermissive) args.push("--claude-permissive")
-      Option.map(config.claudeModel, (m) => args.push(`--claude-model=${m}`))
-      Option.map(config.claudeEffort, (level) => args.push(`--claude-effort=${level}`))
-      Option.map(config.claudeAdvisor, (state) => args.push(`--claude-advisor=${state}`))
-      Option.map(config.claudeCompactWindow, (w) => args.push(`--claude-compact-window=${w}`))
-      Option.map(config.codexModel, (m) => args.push(`--codex-model=${m}`))
-      Option.map(config.codexEffort, (level) => args.push(`--codex-effort=${level}`))
+      const args: Array<string> = ["sync", ...config.targets];
+      if (config.dryRun) args.push("--dry-run");
+      if (config.reconcile) args.push("--reconcile");
+      if (config.prune) args.push("--prune");
+      if (config.skipBubblewrap) args.push("--skip-bubblewrap");
+      if (config.skipPluginRefresh) args.push("--skip-plugin-refresh");
+      if (config.verbose) args.push("--verbose");
+      if (config.claudePermissive) args.push("--claude-permissive");
+      Option.map(config.claudeModel, (m) => args.push(`--claude-model=${m}`));
+      Option.map(config.claudeEffort, (level) => args.push(`--claude-effort=${level}`));
+      Option.map(config.claudeAdvisor, (state) => args.push(`--claude-advisor=${state}`));
+      Option.map(config.claudeCompactWindow, (w) => args.push(`--claude-compact-window=${w}`));
+      Option.map(config.codexModel, (m) => args.push(`--codex-model=${m}`));
+      Option.map(config.codexEffort, (level) => args.push(`--codex-effort=${level}`));
       for (const occurrence of config.claudePlugin) {
         if (occurrence.trim() === "") {
-          args.push("--claude-plugin=")
-          continue
+          args.push("--claude-plugin=");
+          continue;
         }
         occurrence
           .split(",")
           .map((p) => p.trim())
           .filter((p) => p.length > 0)
-          .forEach((p) => args.push(`--claude-plugin=${p}`))
+          .forEach((p) => args.push(`--claude-plugin=${p}`));
       }
 
       // Not on --dry-run: the nudge's git fetch writes FETCH_HEAD/remote
       // refs, and a preview command must not mutate the checkout.
       if (!config.dryRun) {
-        const logger = yield* LoggerService
-        yield* Effect.sync(() => updateNudge(logger))
+        const logger = yield* LoggerService;
+        yield* Effect.sync(() => updateNudge(logger));
       }
-      yield* engine(args)
-    })
+      yield* engine(args);
+    }),
 ).pipe(
   Command.withDescription(
-    "Deploy the SoT to this machine with EngineNative. Deploy-time modifiers touch deployed config only; a later flag-less sync reverts them to SoT."
-  )
-)
+    "Deploy the SoT to this machine with EngineNative. Deploy-time modifiers touch deployed config only; a later flag-less sync reverts them to SoT.",
+  ),
+);

package/cli/src/commands/toolchain.ts

@@ -1,44 +1,44 @@
-import { Argument, Command, Flag } from "effect/unstable/cli"
-import { Effect, Option } from "effect"
-import { bail, engine } from "../engine"
+import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Effect, Option } from "effect";
+import { bail, engine } from "../engine";
 
-const MANAGED = ["bun"]
+const MANAGED = ["bun"];
 
 const op = Argument.String("op").pipe(
   Argument.withDescription("check (default) | ensure <tool>"),
-  Argument.optional
-)
+  Argument.optional,
+);
 const tool = Argument.String("tool").pipe(
   Argument.withDescription(`Managed tool for ensure: ${MANAGED.join(", ")}`),
-  Argument.optional
-)
+  Argument.optional,
+);
 const verbose = Flag.Boolean("verbose").pipe(
   Flag.withAlias("v"),
   Flag.withDescription("Also print no-op confirmations (present, up to date)"),
-  Flag.withDefault(false)
-)
+  Flag.withDefault(false),
+);
 
 export const toolchainCommand = Command.make("toolchain", { op, tool, verbose }, (config) =>
   Effect.gen(function* () {
-    const operation = Option.getOrElse(config.op, () => "check")
-    const flags = config.verbose ? ["--verbose"] : []
+    const operation = Option.getOrElse(config.op, () => "check");
+    const flags = config.verbose ? ["--verbose"] : [];
 
     switch (operation) {
       case "check":
-        return yield* engine(["toolchain", "check", ...(config.verbose ? ["--verbose"] : [])])
+        return yield* engine(["toolchain", "check", ...(config.verbose ? ["--verbose"] : [])]);
       case "ensure": {
-        const t = Option.getOrUndefined(config.tool)
+        const t = Option.getOrUndefined(config.tool);
         if (t === undefined || !MANAGED.includes(t)) {
-          return yield* bail(`toolchain ensure needs a managed tool: ${MANAGED.join(", ")}`)
+          return yield* bail(`toolchain ensure needs a managed tool: ${MANAGED.join(", ")}`);
         }
-        return yield* engine(["toolchain", "ensure", t, ...flags])
+        return yield* engine(["toolchain", "ensure", t, ...flags]);
       }
       default:
-        return yield* bail(`Unknown toolchain op '${operation}' (valid: check, ensure)`)
+        return yield* bail(`Unknown toolchain op '${operation}' (valid: check, ensure)`);
     }
-  })
+  }),
 ).pipe(
   Command.withDescription(
-    "Verified-version floors for external tools (SoT/toolchain.json): check prints the doctor table; ensure installs one managed tool when it is missing."
-  )
-)
+    "Verified-version floors for external tools (SoT/toolchain.json): check prints the doctor table; ensure installs one managed tool when it is missing.",
+  ),
+);