javi-forge 1.37.1 → 1.38.1

package/ci-local/uninstall.sh

@@ -13,10 +13,40 @@
 #   ./uninstall.sh --purge               # also rm -rf ci-local/ + lib/common.sh
 # =============================================================================
 
-set -e
 
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+CI_LOCAL_ENTRYPOINT_SOURCE="${BASH_SOURCE[0]}"
+if [[ "$CI_LOCAL_ENTRYPOINT_SOURCE" == /* ]]; then
+    CI_LOCAL_ENTRYPOINT_PATH="$CI_LOCAL_ENTRYPOINT_SOURCE"
+else
+    CI_LOCAL_ENTRYPOINT_PATH="$PWD/$CI_LOCAL_ENTRYPOINT_SOURCE"
+fi
+CI_LOCAL_ENTRYPOINT_DIR="${CI_LOCAL_ENTRYPOINT_PATH%/*}"
+
+function ci_local_normalize_platform() {
+    local platform="${1:?platform required}"
+
+    case "$platform" in
+        MINGW*_NT-*|MSYS*|CYGWIN*) printf '%s\n' 'Windows' ;;
+        *) printf '%s\n' "$platform" ;;
+    esac
+}
+
+function ci_local_main() {
+    local platform
+    platform="$(ci_local_normalize_platform "${1:?platform required}")"
+    shift
+
+    case "$platform" in
+        Linux|Windows) ci_local_startup_body "$@" ;;
+        *) printf '%s\n' 'unsupported-platform: javi-forge supports Linux and Windows only.'; return 1 ;;
+    esac
+}
+
+function ci_local_startup_body() {
+    set -e
+
+SCRIPT_DIR="$CI_LOCAL_ENTRYPOINT_DIR"
+PROJECT_DIR="${SCRIPT_DIR%/*}"
 
 # Source colors if available; degrade gracefully if not.
 if [ -f "$SCRIPT_DIR/../lib/common.sh" ]; then
@@ -93,3 +123,8 @@ fi
 echo -e ""
 echo -e "${GREEN}Uninstall complete!${NC}"
 echo -e ""
+}
+
+if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then
+    ci_local_main "$(/usr/bin/uname -s)" "$@"
+fi

package/dist/cli/bootstrap.d.ts

@@ -0,0 +1,12 @@
+export type BootstrapResult = {
+    state: "supported";
+    exitCode: 0;
+} | {
+    state: "unsupported-platform";
+    exitCode: 1;
+};
+export interface SupportedCli {
+    runCli: () => Promise<void>;
+}
+export declare function bootstrapCli(platform: string, loadSupportedCli: () => Promise<SupportedCli>, refuse: (message: string) => void): Promise<BootstrapResult>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/cli/bootstrap.js

@@ -0,0 +1,12 @@
+import { resolvePlatformSupport } from "../lib/platform-support.js";
+export async function bootstrapCli(platform, loadSupportedCli, refuse) {
+    const refusal = resolvePlatformSupport(platform);
+    if (refusal) {
+        refuse(`${refusal.refusalCode}: ${refusal.guidance}`);
+        return { state: "unsupported-platform", exitCode: 1 };
+    }
+    const supportedCli = await loadSupportedCli();
+    await supportedCli.runCli();
+    return { state: "supported", exitCode: 0 };
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/cli/dispatch/simple-renderers.d.ts

@@ -7,8 +7,15 @@
  * Ink + React are already eagerly imported at the entrypoint, so importing the
  * concrete UI components at the top of this file does NOT worsen cold-start.
  */
+import { render } from "ink";
 import type { CLI, RendererCtx } from "./types.js";
-export declare function handleDoctor(_cli: CLI, ctx: RendererCtx): void;
+export interface RendererDeps {
+    platform?: string;
+    render?: typeof render;
+    error?: (message: string) => void;
+    setExitCode?: (code: number) => void;
+}
+export declare function handleDoctor(_cli: CLI, ctx: RendererCtx, deps?: RendererDeps): void;
 export declare function handleAnalyze(cli: CLI, ctx: RendererCtx): void;
 export declare function handleLlmsTxt(cli: CLI, ctx: RendererCtx): void;
 export declare function handlePlugin(cli: CLI, ctx: RendererCtx): void;

package/dist/cli/dispatch/simple-renderers.js

@@ -17,8 +17,17 @@ import Doctor from "../../ui/Doctor.js";
 import LlmsTxt from "../../ui/LlmsTxt.js";
 import Plugin from "../../ui/Plugin.js";
 import { VALID_CI, VALID_MEMORY, VALID_STACKS } from "../validators.js";
-export function handleDoctor(_cli, ctx) {
-    render(React.createElement(CIContextProvider, { isCI: ctx.isCI },
+export function handleDoctor(_cli, ctx, deps = {}) {
+    const platformSupport = resolvePlatformSupport(deps.platform ?? process.platform);
+    if (platformSupport) {
+        (deps.error ?? console.error)(`${platformSupport.refusalCode}: ${platformSupport.guidance}`);
+        (deps.setExitCode ??
+            ((code) => {
+                process.exitCode = code;
+            }))(1);
+        return;
+    }
+    (deps.render ?? render)(React.createElement(CIContextProvider, { isCI: ctx.isCI },
         React.createElement(Doctor, null)), { stdin: ctx.inkStdin });
 }
 export function handleAnalyze(cli, ctx) {

package/dist/cli/main.d.ts

@@ -0,0 +1,2 @@
+export declare function runCli(): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

package/dist/cli/main.js

@@ -0,0 +1,85 @@
+import { createRequire } from "node:module";
+import meow from "meow";
+import { handleCi } from "./dispatch/ci.js";
+import { handleHooks } from "./dispatch/hooks.js";
+import { handleSecurity } from "./dispatch/security.js";
+import { handleAnalyze, handleDoctor, handleInitDefault, handleLlmsTxt, handlePlugin, } from "./dispatch/simple-renderers.js";
+import { handleSkillPublish } from "./dispatch/skill-publish.js";
+import { handleSkillsCmd } from "./dispatch/skills-cmd.js";
+import { handleTdd } from "./dispatch/tdd.js";
+import { handleWorkflow } from "./dispatch/workflow.js";
+import { FLAGS_SCHEMA, HELP_TEXT } from "./help.js";
+import { createInkStdin, detectCI, setupUpdateNotifier } from "./runtime.js";
+export async function runCli() {
+    // Check for updates in background (non-blocking, cached 24h)
+    const _require = createRequire(import.meta.url);
+    const pkg = _require("../../package.json");
+    setupUpdateNotifier(pkg);
+    const cli = meow(HELP_TEXT, {
+        importMeta: import.meta,
+        flags: FLAGS_SCHEMA,
+        // Handle --help manually so `ci --help` can show ci-specific usage instead
+        // of the global banner (meow's autoHelp would print + exit before dispatch).
+        autoHelp: false,
+    });
+    const subcommand = cli.input[0] ?? "init";
+    // Global --help: every command except `ci` and `hooks` shows the global banner
+    // here. Those two own their per-command help inside their handlers.
+    if (cli.flags.help && subcommand !== "ci" && subcommand !== "hooks") {
+        console.log(HELP_TEXT);
+        process.exit(0);
+    }
+    const isCI = detectCI(cli.flags);
+    const inkStdin = createInkStdin();
+    switch (subcommand) {
+        case "tdd": {
+            await handleTdd(cli);
+            break;
+        }
+        case "ci": {
+            await handleCi(cli, { inkStdin, isCI });
+            break;
+        }
+        case "hooks": {
+            await handleHooks(cli);
+            break;
+        }
+        case "doctor": {
+            handleDoctor(cli, { inkStdin, isCI });
+            break;
+        }
+        case "analyze": {
+            handleAnalyze(cli, { inkStdin, isCI });
+            break;
+        }
+        case "workflow": {
+            await handleWorkflow(cli);
+            break;
+        }
+        case "llms-txt": {
+            handleLlmsTxt(cli, { inkStdin, isCI });
+            break;
+        }
+        case "plugin": {
+            handlePlugin(cli, { inkStdin, isCI });
+            break;
+        }
+        case "skills": {
+            await handleSkillsCmd(cli, { inkStdin, isCI });
+            break;
+        }
+        case "skill": {
+            await handleSkillPublish(cli);
+            break;
+        }
+        case "security": {
+            await handleSecurity(cli);
+            break;
+        }
+        default: {
+            handleInitDefault(cli, { inkStdin, isCI });
+            break;
+        }
+    }
+}
+//# sourceMappingURL=main.js.map

package/dist/commands/claude-hooks.d.ts

@@ -17,6 +17,7 @@ import { doctorClaudePreToolUse, installClaudePreToolUse, repairClaudePreToolUse
 export type ClaudeHookSub = "install" | "doctor" | "repair";
 /** Injectable seams for tests; each defaults to the real implementation. */
 export interface ClaudeHookCmdDeps {
+    platform?: string;
     install?: typeof installClaudePreToolUse;
     doctor?: typeof doctorClaudePreToolUse;
     repair?: typeof repairClaudePreToolUse;

package/dist/commands/claude-hooks.js

@@ -14,6 +14,7 @@
  * current.
  */
 import { doctorClaudePreToolUse, installClaudePreToolUse, repairClaudePreToolUse, } from "../lib/claude-hook-manager.js";
+import { resolvePlatformSupport } from "../lib/platform-support.js";
 import { remediationForMessage } from "../lib/secure-refusal-remediation.js";
 /**
  * Warnings are NON-BLOCKING notices, so they go to stdout under their own
@@ -57,10 +58,13 @@ function renderMutation(verb, result, log, logError) {
     renderWarnings(result.warnings, log);
     return 1;
 }
-function renderDoctor(report, log) {
+function renderDoctor(result, log) {
+    if ("state" in result) {
+        log(`${result.platformSupport.refusalCode}: ${result.platformSupport.guidance}`);
+        return 1;
+    }
+    const report = result;
     log(`doctor claude: ${report.healthy ? "healthy" : "unhealthy"}`);
-    if (report.platformSupport)
-        log(`  platform-support: ${report.platformSupport.state} — ${report.platformSupport.guidance}`);
     log(`  settings: ${report.settings.state} — ${report.settings.detail}`);
     log(`  asset:    ${report.asset.state} — ${report.asset.detail}`);
     log(`  node:     ${report.node.version ?? "unavailable"} (min-satisfied: ${report.node.satisfiesMinimum})`);
@@ -124,6 +128,11 @@ function renderDoctor(report, log) {
 export async function runClaudeHookCommand(sub, projectDir, opts, deps = {}) {
     const log = deps.log ?? ((m) => console.log(m));
     const logError = deps.logError ?? ((m) => console.error(m));
+    const platformSupport = resolvePlatformSupport(deps.platform ?? process.platform);
+    if (platformSupport) {
+        logError(`${platformSupport.refusalCode}: ${platformSupport.guidance}`);
+        return 1;
+    }
     const install = deps.install ?? installClaudePreToolUse;
     const doctor = deps.doctor ?? doctorClaudePreToolUse;
     const repair = deps.repair ?? repairClaudePreToolUse;

package/dist/commands/codex-hooks.d.ts

@@ -13,6 +13,7 @@
 import { doctorCodexPreToolUse, installCodexPreToolUse, repairCodexPreToolUse } from "../lib/codex-hook-manager.js";
 export type CodexHookSub = "install" | "doctor" | "repair";
 export interface CodexHookCmdDeps {
+    platform?: string;
     install?: typeof installCodexPreToolUse;
     doctor?: typeof doctorCodexPreToolUse;
     repair?: typeof repairCodexPreToolUse;

package/dist/commands/codex-hooks.js

@@ -11,6 +11,7 @@
  * install correctly reports blocked until the user grants trust.
  */
 import { doctorCodexPreToolUse, installCodexPreToolUse, repairCodexPreToolUse, } from "../lib/codex-hook-manager.js";
+import { resolvePlatformSupport } from "../lib/platform-support.js";
 function renderWarnings(warnings, log) {
     if (warnings.length === 0)
         return;
@@ -42,10 +43,13 @@ function renderMutation(verb, result, log, logError) {
     renderWarnings(result.warnings, log);
     return 1;
 }
-function renderDoctor(report, log) {
+function renderDoctor(result, log) {
+    if ("state" in result) {
+        log(`${result.platformSupport.refusalCode}: ${result.platformSupport.guidance}`);
+        return 1;
+    }
+    const report = result;
     log(`doctor codex: ${report.healthy ? "healthy" : "unhealthy"}`);
-    if (report.platformSupport)
-        log(`  platform-support: ${report.platformSupport.state} — ${report.platformSupport.guidance}`);
     log(`  hooks.json: ${report.hooksJson.state}`);
     log(`  config:    [features] hooks=${report.config.featuresHooks} (readable: ${report.config.readable})`);
     log(`  trust:     ${report.trust.state}`);
@@ -88,6 +92,11 @@ function renderDoctor(report, log) {
 export async function runCodexHookCommand(sub, _cwd, opts, deps = {}) {
     const log = deps.log ?? ((m) => console.log(m));
     const logError = deps.logError ?? ((m) => console.error(m));
+    const platformSupport = resolvePlatformSupport(deps.platform ?? process.platform);
+    if (platformSupport) {
+        logError(`${platformSupport.refusalCode}: ${platformSupport.guidance}`);
+        return 1;
+    }
     const install = deps.install ?? installCodexPreToolUse;
     const doctor = deps.doctor ?? doctorCodexPreToolUse;
     const repair = deps.repair ?? repairCodexPreToolUse;

package/dist/commands/doctor.d.ts

@@ -1,5 +1,20 @@
+import fs from "fs-extra";
+import { detectStack } from "../lib/common.js";
+import { refreshContextDir } from "../lib/context.js";
+import { execFileAsync } from "../lib/exec.js";
+import { listInstalledPlugins } from "../lib/plugin.js";
 import type { DoctorResult } from "../types/index.js";
 export type CheckStatus = "ok" | "fail" | "skip";
+type DoctorFilesystem = Pick<typeof fs, "pathExists" | "readJson" | "readdir">;
+export interface DoctorDeps {
+    platform?: string;
+    cwd?: () => string;
+    filesystem?: DoctorFilesystem;
+    exec?: typeof execFileAsync;
+    stackDetector?: typeof detectStack;
+    pluginLister?: typeof listInstalledPlugins;
+    contextRefresher?: typeof refreshContextDir;
+}
 interface RemoteInfo {
     host: "github" | "gitlab" | "other";
     owner: string;
@@ -10,6 +25,6 @@ export declare function parseRemote(url: string): RemoteInfo | null;
 /**
  * Run comprehensive health checks for the project and framework.
  */
-export declare function runDoctor(projectDir?: string): Promise<DoctorResult>;
+export declare function runDoctor(projectDir?: string, deps?: DoctorDeps): Promise<DoctorResult>;
 export {};
 //# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.js

@@ -4,40 +4,45 @@ import { FORGE_ROOT, MODULES_DIR, PLUGINS_DIR, TEMPLATES_DIR, } from "../constan
 import { detectStack } from "../lib/common.js";
 import { refreshContextDir } from "../lib/context.js";
 import { execFileAsync } from "../lib/exec.js";
+import { resolvePlatformSupport } from "../lib/platform-support.js";
 import { listInstalledPlugins } from "../lib/plugin.js";
-/** Resolve a binary name to its full path, returns null if not found */
-async function which(bin) {
+/** Resolve a binary name to its first full path, returns null if not found. */
+async function which(bin, exec, platform) {
     try {
-        const { stdout } = await execFileAsync("which", [bin]);
-        return stdout.trim() || null;
+        const command = platform === "win32" ? "where.exe" : "which";
+        const { stdout } = await exec(command, [bin]);
+        return (stdout
+            .split(/\r?\n/)
+            .map((entry) => entry.trim())
+            .find(Boolean) ?? null);
     }
     catch {
         return null;
     }
 }
 /** Read the forge manifest from a project directory */
-async function readManifest(projectDir) {
+async function readManifest(projectDir, filesystem) {
     const manifestPath = path.join(projectDir, ".javi-forge", "manifest.json");
-    if (!(await fs.pathExists(manifestPath)))
+    if (!(await filesystem.pathExists(manifestPath)))
         return null;
     try {
-        return (await fs.readJson(manifestPath));
+        return (await filesystem.readJson(manifestPath));
     }
     catch {
         return null;
     }
 }
 /** Count entries in a directory */
-async function countDir(dir) {
-    if (!(await fs.pathExists(dir)))
+async function countDir(dir, filesystem) {
+    if (!(await filesystem.pathExists(dir)))
         return 0;
-    const entries = await fs.readdir(dir);
+    const entries = await filesystem.readdir(dir);
     return entries.filter((e) => !e.startsWith(".")).length;
 }
 /** Read a single git config value, "" when unset or on any error. */
-async function gitConfigValue(cwd, key) {
+async function gitConfigValue(cwd, key, exec) {
     try {
-        const { stdout } = await execFileAsync("git", ["config", "--get", key], {
+        const { stdout } = await exec("git", ["config", "--get", key], {
             cwd,
         });
         return stdout.trim();
@@ -70,9 +75,9 @@ export function parseRemote(url) {
  * a recommendation, never a gate (a hook enforcing it was trivially bypassed
  * with `--no-verify`).
  */
-async function commitSigningCheck(cwd) {
-    const gpgSign = await gitConfigValue(cwd, "commit.gpgsign");
-    const signingKey = await gitConfigValue(cwd, "user.signingkey");
+async function commitSigningCheck(cwd, exec) {
+    const gpgSign = await gitConfigValue(cwd, "commit.gpgsign", exec);
+    const signingKey = await gitConfigValue(cwd, "user.signingkey", exec);
     if (gpgSign === "true" && signingKey) {
         return {
             label: "Commit signing",
@@ -93,8 +98,8 @@ async function commitSigningCheck(cwd) {
  * probe or protection is a non-alarming `skip` (advisory, not a failure).
  * GitLab or no `gh` → `skip` with a note to verify in the forge UI.
  */
-async function branchProtectionCheck(cwd) {
-    const remote = parseRemote(await gitConfigValue(cwd, "remote.origin.url"));
+async function branchProtectionCheck(cwd, exec, platform) {
+    const remote = parseRemote(await gitConfigValue(cwd, "remote.origin.url", exec));
     const label = "Branch protection";
     if (!remote || remote.host === "other") {
         return {
@@ -103,7 +108,7 @@ async function branchProtectionCheck(cwd) {
             detail: "no GitHub/GitLab origin — verify branch protection in the forge UI",
         };
     }
-    if (remote.host === "gitlab" || !(await which("gh"))) {
+    if (remote.host === "gitlab" || !(await which("gh", exec, platform))) {
         return {
             label,
             status: "skip",
@@ -113,14 +118,14 @@ async function branchProtectionCheck(cwd) {
     // gh + GitHub: resolve the default branch, then probe protection.
     let branch = "main";
     try {
-        const { stdout } = await execFileAsync("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], { cwd });
+        const { stdout } = await exec("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], { cwd });
         branch = stdout.trim().replace(/^origin\//, "") || "main";
     }
     catch {
         /* fall back to main */
     }
     try {
-        await execFileAsync("gh", [
+        await exec("gh", [
             "api",
             `repos/${remote.owner}/${remote.repo}/branches/${branch}/protection`,
         ]);
@@ -141,8 +146,22 @@ async function branchProtectionCheck(cwd) {
 /**
  * Run comprehensive health checks for the project and framework.
  */
-export async function runDoctor(projectDir) {
-    const cwd = projectDir ?? process.cwd();
+export async function runDoctor(projectDir, deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const platformSupport = resolvePlatformSupport(platform);
+    if (platformSupport) {
+        return {
+            state: "unsupported-platform",
+            guidance: platformSupport.guidance,
+            sections: [],
+        };
+    }
+    const cwd = projectDir ?? (deps.cwd ?? process.cwd)();
+    const filesystem = deps.filesystem ?? fs;
+    const exec = deps.exec ?? execFileAsync;
+    const stackDetector = deps.stackDetector ?? detectStack;
+    const pluginLister = deps.pluginLister ?? listInstalledPlugins;
+    const contextRefresher = deps.contextRefresher ?? refreshContextDir;
     const sections = [];
     // ── 1. System Tools ────────────────────────────────────────────────────────
     const toolChecks = [];
@@ -154,12 +173,12 @@ export async function runDoctor(projectDir) {
         { name: "pnpm", label: "pnpm" },
     ];
     for (const tool of tools) {
-        const bin = await which(tool.name);
+        const bin = await which(tool.name, exec, platform);
         if (bin) {
             // Try to get version
             let version = "";
             try {
-                const { stdout } = await execFileAsync(tool.name, ["--version"]);
+                const { stdout } = await exec(tool.name, ["--version"]);
                 version = stdout.trim().split("\n")[0] ?? "";
             }
             catch {
@@ -184,8 +203,8 @@ export async function runDoctor(projectDir) {
     // L4/L6 (commit signing) and L5 (branch protection) are advisories, NOT hooks
     // (hook-consolidation D9): doctor reports, nothing blocks.
     const securityChecks = [
-        await commitSigningCheck(cwd),
-        await branchProtectionCheck(cwd),
+        await commitSigningCheck(cwd, exec),
+        await branchProtectionCheck(cwd, exec, platform),
     ];
     sections.push({ title: "Security", checks: securityChecks });
     // ── 2. Framework Structure ─────────────────────────────────────────────────
@@ -197,8 +216,8 @@ export async function runDoctor(projectDir) {
         { path: path.join(FORGE_ROOT, "ci-local"), label: "ci-local/" },
     ];
     for (const dir of expectedDirs) {
-        if (await fs.pathExists(dir.path)) {
-            const count = await countDir(dir.path);
+        if (await filesystem.pathExists(dir.path)) {
+            const count = await countDir(dir.path, filesystem);
             structureChecks.push({
                 label: dir.label,
                 status: "ok",
@@ -216,7 +235,7 @@ export async function runDoctor(projectDir) {
     sections.push({ title: "Framework Structure", checks: structureChecks });
     // ── 3. Stack Detection ─────────────────────────────────────────────────────
     const stackChecks = [];
-    const detection = await detectStack(cwd);
+    const detection = await stackDetector(cwd);
     if (detection) {
         stackChecks.push({
             label: "Detected stack",
@@ -234,7 +253,7 @@ export async function runDoctor(projectDir) {
     sections.push({ title: "Stack Detection", checks: stackChecks });
     // ── 4. Project Manifest ────────────────────────────────────────────────────
     const manifestChecks = [];
-    const manifest = await readManifest(cwd);
+    const manifest = await readManifest(cwd, filesystem);
     if (manifest) {
         manifestChecks.push({
             label: "Forge manifest",
@@ -267,7 +286,7 @@ export async function runDoctor(projectDir) {
     const moduleNames = ["engram", "obsidian-brain", "memory-simple", "ghagga"];
     for (const mod of moduleNames) {
         const modPath = path.join(cwd, ".javi-forge", "modules", mod);
-        if (await fs.pathExists(modPath)) {
+        if (await filesystem.pathExists(modPath)) {
             moduleChecks.push({ label: mod, status: "ok", detail: "installed" });
         }
         else {
@@ -281,9 +300,9 @@ export async function runDoctor(projectDir) {
     sections.push({ title: "Installed Modules", checks: moduleChecks });
     // ── 6. Plugins ─────────────────────────────────────────────────────────────
     const pluginChecks = [];
-    const pluginsDirExists = await fs.pathExists(PLUGINS_DIR);
+    const pluginsDirExists = await filesystem.pathExists(PLUGINS_DIR);
     if (pluginsDirExists) {
-        const plugins = await listInstalledPlugins();
+        const plugins = await pluginLister();
         if (plugins.length > 0) {
             for (const plugin of plugins) {
                 pluginChecks.push({
@@ -312,7 +331,7 @@ export async function runDoctor(projectDir) {
     // ── 7. Context Directory Refresh ───────────────────────────────────────────
     const contextChecks = [];
     try {
-        const result = await refreshContextDir(cwd);
+        const result = await contextRefresher(cwd);
         if (result) {
             contextChecks.push({
                 label: ".context/ refresh",
@@ -345,6 +364,6 @@ export async function runDoctor(projectDir) {
         });
     }
     sections.push({ title: "Context Directory", checks: contextChecks });
-    return { sections };
+    return { state: "supported", sections };
 }
 //# sourceMappingURL=doctor.js.map

package/dist/commands/init.d.ts

@@ -14,5 +14,8 @@ export type InitProjectResult = {
     refusalCode: string;
     platformSupport: PlatformSupport;
 };
-export declare function initProject(options: InitOptions, onStep: StepCallback): Promise<InitProjectResult>;
+export interface InitProjectDeps {
+    platform?: string;
+}
+export declare function initProject(options: InitOptions, onStep: StepCallback, deps?: InitProjectDeps): Promise<InitProjectResult>;
 //# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -16,8 +16,8 @@ import { stepMemory } from "./init/steps/memory.js";
 import { stepMock } from "./init/steps/mock.js";
 import { stepSDD } from "./init/steps/sdd.js";
 import { stepSecurityHooks } from "./init/steps/security.js";
-export async function initProject(options, onStep) {
-    const platformSupport = resolvePlatformSupport(process.platform);
+export async function initProject(options, onStep, deps = {}) {
+    const platformSupport = resolvePlatformSupport(deps.platform ?? process.platform);
     if (platformSupport) {
         return {
             ok: false,

package/dist/index.js

@@ -1,84 +1,7 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-import meow from "meow";
-import { handleCi } from "./cli/dispatch/ci.js";
-import { handleHooks } from "./cli/dispatch/hooks.js";
-import { handleSecurity } from "./cli/dispatch/security.js";
-import { handleAnalyze, handleDoctor, handleInitDefault, handleLlmsTxt, handlePlugin, } from "./cli/dispatch/simple-renderers.js";
-import { handleSkillPublish } from "./cli/dispatch/skill-publish.js";
-import { handleSkillsCmd } from "./cli/dispatch/skills-cmd.js";
-import { handleTdd } from "./cli/dispatch/tdd.js";
-import { handleWorkflow } from "./cli/dispatch/workflow.js";
-import { FLAGS_SCHEMA, HELP_TEXT } from "./cli/help.js";
-import { createInkStdin, detectCI, setupUpdateNotifier, } from "./cli/runtime.js";
-// Check for updates in background (non-blocking, cached 24h)
-const _require = createRequire(import.meta.url);
-const pkg = _require("../package.json");
-setupUpdateNotifier(pkg);
-const cli = meow(HELP_TEXT, {
-    importMeta: import.meta,
-    flags: FLAGS_SCHEMA,
-    // Handle --help manually so `ci --help` can show ci-specific usage instead
-    // of the global banner (meow's autoHelp would print + exit before dispatch).
-    autoHelp: false,
-});
-const subcommand = cli.input[0] ?? "init";
-// Global --help: every command except `ci` and `hooks` shows the global banner
-// here. Those two own their per-command help inside their handlers.
-if (cli.flags.help && subcommand !== "ci" && subcommand !== "hooks") {
-    console.log(HELP_TEXT);
-    process.exit(0);
-}
-const isCI = detectCI(cli.flags);
-const inkStdin = createInkStdin();
-switch (subcommand) {
-    case "tdd": {
-        await handleTdd(cli);
-        break;
-    }
-    case "ci": {
-        await handleCi(cli, { inkStdin, isCI });
-        break;
-    }
-    case "hooks": {
-        await handleHooks(cli);
-        break;
-    }
-    case "doctor": {
-        handleDoctor(cli, { inkStdin, isCI });
-        break;
-    }
-    case "analyze": {
-        handleAnalyze(cli, { inkStdin, isCI });
-        break;
-    }
-    case "workflow": {
-        await handleWorkflow(cli);
-        break;
-    }
-    case "llms-txt": {
-        handleLlmsTxt(cli, { inkStdin, isCI });
-        break;
-    }
-    case "plugin": {
-        handlePlugin(cli, { inkStdin, isCI });
-        break;
-    }
-    case "skills": {
-        await handleSkillsCmd(cli, { inkStdin, isCI });
-        break;
-    }
-    case "skill": {
-        await handleSkillPublish(cli);
-        break;
-    }
-    case "security": {
-        await handleSecurity(cli);
-        break;
-    }
-    default: {
-        handleInitDefault(cli, { inkStdin, isCI });
-        break;
-    }
+import { bootstrapCli } from "./cli/bootstrap.js";
+const bootstrapResult = await bootstrapCli(process.platform, () => import("./cli/main.js"), (message) => console.error(message));
+if (bootstrapResult.state === "unsupported-platform") {
+    process.exitCode = bootstrapResult.exitCode;
 }
 //# sourceMappingURL=index.js.map