@shrkcrft/cli 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/main.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { loadDotenv } from "./env/load-dotenv.js";
 import { CommandRegistry, extractGlobalCwd, parseArgs, } from "./command-registry.js";
 import { initCommand } from "./commands/init.command.js";
 import { inspectCommand } from "./commands/inspect.command.js";
@@ -55,6 +56,12 @@ import { dashboardCommand } from "./commands/dashboard.command.js";
 import { dashboardDiffCommand, dashboardExportCommand, } from "./commands/dashboard-export.command.js";
 import { importCommand } from "./commands/import.command.js";
 import { askCommand } from "./commands/ask.command.js";
+import { smartContextCommand, smartContextEmbeddingsBuildCommand, smartContextEmbeddingsStatusCommand, smartContextListCommand, smartContextPlanAheadCommand, smartContextShowCommand, } from "./commands/smart-context.command.js";
+import { spikeCommand } from "./commands/spike.command.js";
+import { depsAuditCommand } from "./commands/deps-audit.command.js";
+import { scaffoldValidateCommand } from "./commands/scaffold-validate.command.js";
+import { movePlanCommand } from "./commands/move-plan.command.js";
+import { watchCommand, watchListCommand, watchPruneCommand, watchStopCommand } from "./commands/watch.command.js";
 import { mcpCommand } from "./commands/mcp.command.js";
 import { versionCommand } from "./commands/version.command.js";
 import { makeHelpCommand } from "./commands/help.command.js";
@@ -204,6 +211,20 @@ export function buildRegistry() {
     registry.register(planParentCommand);
     registry.register(devCommand);
     registry.register(askCommand);
+    registry.register(smartContextCommand);
+    registry.registerSubcommand('smart-context', smartContextPlanAheadCommand);
+    registry.registerSubcommand('smart-context', smartContextListCommand);
+    registry.registerSubcommand('smart-context', smartContextShowCommand);
+    registry.registerSubcommand('smart-context', smartContextEmbeddingsBuildCommand);
+    registry.registerSubcommand('smart-context', smartContextEmbeddingsStatusCommand);
+    registry.register(spikeCommand);
+    registry.register(depsAuditCommand);
+    registry.register(scaffoldValidateCommand);
+    registry.register(movePlanCommand);
+    registry.register(watchCommand);
+    registry.registerSubcommand('watch', watchListCommand);
+    registry.registerSubcommand('watch', watchStopCommand);
+    registry.registerSubcommand('watch', watchPruneCommand);
     registry.register(mcpCommand);
     registry.register(versionCommand);
     registry.register(qualityCommand);
@@ -804,9 +825,69 @@ if (isMain ||
     entryPath.endsWith('shrk') ||
     entryPath.endsWith('shrk.js') ||
     entryPath.endsWith('shrk.cmd')) {
+    loadDotenv(process.cwd());
     const argv = process.argv.slice(2);
-    runCli(argv).then((code) => process.exit(code), (err) => {
+    const cleanShutdown = async (code) => {
+        // Best-effort teardown of shared native runtimes. Without this,
+        // commands that loaded native libs (ONNX via embeddings; Metal
+        // via node-llama-cpp) abort during `process.exit` AFTER the
+        // work completed — the user sees their result then `zsh: abort`.
+        // Dynamic imports keep these off the hot path for commands that
+        // never touched them.
+        try {
+            const mod = (await import('@shrkcrft/embeddings'));
+            if (typeof mod.disposeSemanticIndexPipeline === 'function') {
+                await mod.disposeSemanticIndexPipeline();
+            }
+        }
+        catch {
+            // Best-effort; never block the exit on teardown failure.
+        }
+        try {
+            const mod = (await import('@shrkcrft/ai'));
+            if (typeof mod.disposeLlamaCppRuntime === 'function') {
+                await mod.disposeLlamaCppRuntime();
+            }
+        }
+        catch {
+            // Best-effort.
+        }
+        // Flush stdio synchronously before bypassing C++ destructors.
+        // `_exit` skips all libc finalizers, which is exactly what we
+        // need (see below), but it also doesn't wait for buffered
+        // writes to drain. Two synchronous write callbacks force the
+        // current buffers through.
+        try {
+            await new Promise((resolve) => process.stdout.write('', () => resolve()));
+            await new Promise((resolve) => process.stderr.write('', () => resolve()));
+        }
+        catch {
+            // ignore flush failures
+        }
+        // Prefer `_exit` over `exit` on Node. Even after our explicit
+        // disposes above, node-llama-cpp's libggml-metal destructor
+        // still aborts in `__cxa_finalize_ranges` because the Metal
+        // device list isn't drained by the current dispose API
+        // (`GGML_ASSERT([rsets->data count] == 0)` fires from
+        // `ggml_metal_device_free`, surfacing as `zsh: abort` AFTER
+        // the user's result has already printed). `process._exit`
+        // skips the libc++ static-destructor pass entirely, which is
+        // safe here because we have already torn down the runtimes
+        // we care about above and the OS will reclaim the rest.
+        //
+        // Bun's process object doesn't expose `_exit`, but Bun also
+        // doesn't drive shutdown through libuv + libc++ static
+        // destructors the same way Node does, so the Metal crash
+        // doesn't reproduce there. Fall back to `process.exit` when
+        // `_exit` is unavailable.
+        const lowLevelExit = process._exit;
+        if (typeof lowLevelExit === 'function') {
+            lowLevelExit(code);
+        }
+        process.exit(code);
+    };
+    runCli(argv).then((code) => cleanShutdown(code), (err) => {
         process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
-        process.exit(1);
+        return cleanShutdown(1);
     });
 }