@shrkcrft/cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/main.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import { CommandRegistry, extractGlobalCwd, parseArgs, } from "./command-registry.js";
 import { initCommand } from "./commands/init.command.js";
 import { inspectCommand } from "./commands/inspect.command.js";
@@ -20,8 +20,17 @@ import { presetsListCommand, presetsGetCommand, presetsExplainCommand, presetsRe
 import { taskCommand } from "./commands/task.command.js";
 import { preflightCommand } from "./commands/preflight.command.js";
 import { checkCommand } from "./commands/check.command.js";
+import { diffCheckCommand } from "./commands/diff-check.command.js";
 import { driftCommand } from "./commands/drift.command.js";
 import { graphCommand } from "./commands/graph.command.js";
+import { ruleGraphCommand } from "./commands/rule-graph-subverbs.js";
+import { searchStructuralCommand } from "./commands/search-structural.command.js";
+import { planContextCommand } from "./commands/plan-context.command.js";
+import { archCommand } from "./commands/arch.command.js";
+import { frameworkCommand } from "./commands/framework.command.js";
+import { apiDiffCommand } from "./commands/api-diff.command.js";
+import { gateCommand } from "./commands/gate.command.js";
+import { migrateCommand } from "./commands/migrate.command.js";
 import { coverageCommand } from "./commands/coverage.command.js";
 import { statsCommand } from "./commands/stats.command.js";
 import { reviewCommand } from "./commands/review.command.js";
@@ -56,7 +65,6 @@ import { biomeCommand } from "./commands/biome.command.js";
 import { ideCommand } from "./commands/ide.command.js";
 import { makeCommandsCommand } from "./commands/commands.command.js";
 import { safetyCommand } from "./commands/safety.command.js";
-import { pluginCommand } from "./commands/plugin.command.js";
 import { profilesCommand } from "./commands/profiles.command.js";
 import { auditProjectCouplingCommand } from "./commands/audit.command.js";
 import { conventionsCommand } from "./commands/conventions.command.js";
@@ -110,6 +118,8 @@ import { lintCommand } from "./commands/lint.command.js";
 import { changesCommand } from "./commands/changes.command.js";
 import { exploreCommand } from "./commands/explore.command.js";
 import { prCommand } from "./commands/pr.command.js";
+import { completionCommand } from "./commands/completion.command.js";
+import { codeIntelCommand } from "./commands/code-intel.command.js";
 import { suggestDidYouMean } from '@shrkcrft/inspector';
 import { COMMAND_CATALOG } from "./commands/command-catalog.js";
 import { errorFooterFor, renderErrorFooter } from "./output/failure-hints.js";
@@ -120,33 +130,6 @@ import { buildSurfaceSummary, findCommandInSummary } from "./surface/surface-sum
 import { makeSurfaceNotEnabledError, renderSurfaceNotEnabledText, SURFACE_NOT_ENABLED_EXIT_CODE, } from "./surface/not-enabled-error.js";
 import { extractCommandPath, recordUsage, sanitizeFlagNames, } from "./usage/usage-log.js";
 import { loadProjectConfig } from '@shrkcrft/config';
-import { initTokenizer } from '@shrkcrft/context';
-import { statSync } from 'node:fs';
-import { resolve as resolvePath } from 'node:path';
-function isUsableDirectory(path) {
-    try {
-        return statSync(path).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-let tokenizerInitPromise = null;
-/**
- * Best-effort one-time upgrade from the estimator to gpt-tokenizer.
- *
- * The estimator is always active before this resolves, so commands that
- * race the load still get a budget-safe (if slightly off) count. Subsequent
- * `countTokens` calls get the real BPE count.
- */
-async function ensureTokenizerReady() {
-    if (process.env.SHARKCRAFT_NO_REAL_TOKENIZER === '1')
-        return;
-    if (!tokenizerInitPromise) {
-        tokenizerInitPromise = initTokenizer().catch(() => false);
-    }
-    await tokenizerInitPromise;
-}
 export function buildRegistry() {
     const registry = new CommandRegistry();
     registry.register(initCommand);
@@ -189,10 +172,19 @@ export function buildRegistry() {
     registry.register(taskCommand);
     registry.register(explainCommand);
     registry.register(checkCommand);
+    registry.register(diffCheckCommand);
     // changed-only preflight orchestrator.
     registry.register(preflightCommand);
     registry.register(driftCommand);
     registry.register(graphCommand);
+    registry.register(ruleGraphCommand);
+    registry.register(searchStructuralCommand);
+    registry.register(planContextCommand);
+    registry.register(archCommand);
+    registry.register(frameworkCommand);
+    registry.register(apiDiffCommand);
+    registry.register(gateCommand);
+    registry.register(migrateCommand);
     registry.register(coverageCommand);
     registry.register(statsCommand);
     registry.register(reviewCommand);
@@ -219,7 +211,6 @@ export function buildRegistry() {
     registry.register(eslintCommand);
     registry.register(biomeCommand);
     registry.register(ideCommand);
-    registry.register(pluginCommand);
     registry.register(profilesCommand);
     registry.registerSubcommand('audit', auditProjectCouplingCommand);
     registry.register(conventionsCommand);
@@ -240,6 +231,8 @@ export function buildRegistry() {
     registry.register(lintCommand);
     registry.register(changesCommand);
     registry.register(prCommand);
+    registry.register(completionCommand);
+    registry.register(codeIntelCommand);
     registry.register(searchCommand);
     registry.register(briefCommand);
     registry.register(releaseCommand);
@@ -518,15 +511,9 @@ async function isUsageEnabled(cwd) {
     }
 }
 async function runCliInner(argv) {
-    await ensureTokenizerReady();
     const registry = buildRegistry();
     // Pre-parse the global --cwd so it can appear anywhere (incl. before the command).
     const { cwd: globalCwd, rest: cleanArgv } = extractGlobalCwd(argv);
-    if (globalCwd !== undefined && !isUsableDirectory(globalCwd)) {
-        process.stderr.write(`error: --cwd "${globalCwd}" is not an existing directory.\n` +
-            `Resolved to: ${resolvePath(globalCwd)}\n`);
-        return 2;
-    }
     const [first] = cleanArgv;
     // bare invocation lands on the curated tiered view.
     if (!first) {
@@ -539,7 +526,14 @@ async function runCliInner(argv) {
         return registry.get('help').run(parseArgs([], { globalCwd }));
     }
     if (first === '--full-help') {
-        return registry.get('help').run(parseArgs(['--full'], { globalCwd }));
+        // Pass through `--all` (catalog dump) and `--verbose` if the user
+        // included them after `--full-help`.
+        const extra = [];
+        if (argv.includes('--all'))
+            extra.push('--all');
+        if (argv.includes('--verbose') || argv.includes('-v'))
+            extra.push('--verbose');
+        return registry.get('help').run(parseArgs(['--full', ...extra], { globalCwd }));
     }
     if (first === '--version' || first === '-v') {
         return registry.get('version').run(parseArgs([], { globalCwd }));
@@ -583,7 +577,7 @@ async function runCliInner(argv) {
         return 2;
     }
     const attempted = probe.slice(0, 2).join(' ');
-    process.stderr.write(`Unknown command: ${attempted}\n`);
+    process.stderr.write(`shrk doesn't have a \`${attempted}\` command.\n`);
     printDidYouMean(attempted);
     return 2;
 }
@@ -691,28 +685,125 @@ async function checkSurfaceGate(matchedPath, cwd) {
         return null;
     }
 }
+// Score thresholds for did-you-mean output. Picked from observed
+// scoring: 1-char-off typos score 8+ on plain commands; 3-4-char-off
+// near-misses score ~5; loose / token-overlap matches score 1-3.
+// Junk matches (frobnicate → bundle diff) can score 8 too because of
+// token overlap, so we sharpen by also requiring the suggestion's
+// command name to be reasonably close in length to the attempt.
+const SUGGEST_CONFIDENT_SCORE = 7;
+const SUGGEST_VISIBLE_SCORE = 3;
+function reorderCandidates(attempted, candidates) {
+    // Stable sort: higher score first, then shorter command (more likely
+    // canonical), then lexicographic. The base suggester returns ties in
+    // arbitrary order — this makes the top suggestion more predictable.
+    const ranked = [...candidates];
+    ranked.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        if (a.command.length !== b.command.length) {
+            return a.command.length - b.command.length;
+        }
+        return a.command < b.command ? -1 : a.command > b.command ? 1 : 0;
+    });
+    return ranked;
+}
+/** Edit distance (Levenshtein). Used to gate did-you-mean confidence. */
+function editDistance(a, b) {
+    const m = a.length;
+    const n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = new Array(n + 1);
+    for (let j = 0; j <= n; j += 1)
+        dp[j] = j;
+    for (let i = 1; i <= m; i += 1) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= n; j += 1) {
+            const tmp = dp[j];
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + cost);
+            prev = tmp;
+        }
+    }
+    return dp[n];
+}
+/**
+ * Suggestion is "confident" when the candidate's top token is close
+ * to the attempt in edit-distance terms — `doctorz`→`doctor` (1 edit)
+ * or `inspct`→`inspect` (1 edit) qualify; `frobnicate`→`bundle` (10
+ * edits) does not, even when the suggester scores them similarly
+ * because of incidental token overlap in descriptions.
+ *
+ * Threshold: edit distance ≤ max(1, attempt.length / 4) AND raw score
+ * meets `SUGGEST_VISIBLE_SCORE`. This catches typical fingers-on-keys
+ * typos while rejecting "you typed something totally different."
+ */
+function isConfidentMatch(attempted, suggestion) {
+    if (suggestion.score < SUGGEST_VISIBLE_SCORE)
+        return false;
+    const lower = attempted.toLowerCase();
+    const head = (suggestion.command.split(/\s+/)[0] ?? suggestion.command).toLowerCase();
+    const dist = editDistance(lower, head);
+    const tolerance = Math.max(1, Math.floor(lower.length / 4));
+    return dist <= tolerance;
+}
 function printDidYouMean(attempted) {
-    const candidates = suggestDidYouMean(COMMAND_CATALOG, [attempted], 3);
-    if (candidates.length === 0) {
-        process.stderr.write("Tip: run `shrk commands suggest \"<partial>\"` or `shrk help` to discover commands.\n");
+    const rawCandidates = suggestDidYouMean(COMMAND_CATALOG, [attempted], 5);
+    const reordered = reorderCandidates(attempted, rawCandidates).filter((c) => c.score >= SUGGEST_VISIBLE_SCORE);
+    if (reordered.length === 0) {
+        process.stderr.write('Run `shrk help` to see the curated commands, or `shrk --full-help` for the full catalog.\n');
+        const footer = errorFooterFor('unknown-command', { task: attempted });
+        if (footer)
+            process.stderr.write(renderErrorFooter(footer));
+        return;
+    }
+    // Confident single-match path: surface ONE suggestion clearly.
+    const top = reordered[0];
+    if (isConfidentMatch(attempted, top)) {
+        process.stderr.write(`Did you mean \`shrk ${top.command}\`?\n`);
+        process.stderr.write(`  ${top.description}\n`);
+        // Second-tier suggestions only if they're also strong.
+        const others = reordered.slice(1, 3).filter((c) => isConfidentMatch(attempted, c));
+        if (others.length > 0) {
+            process.stderr.write('Other close matches:\n');
+            for (const c of others) {
+                process.stderr.write(`  shrk ${c.command} — ${c.description}\n`);
+            }
+        }
         const footer = errorFooterFor('unknown-command', { task: attempted });
         if (footer)
             process.stderr.write(renderErrorFooter(footer));
         return;
     }
-    process.stderr.write('Did you mean:\n');
-    for (const c of candidates) {
+    // Low-confidence: show up to 3 as "closest matches", honest about
+    // not knowing which is right.
+    process.stderr.write('Closest matches in the catalog:\n');
+    for (const c of reordered.slice(0, 3)) {
         process.stderr.write(`  shrk ${c.command} — ${c.description}\n`);
     }
-    // append the standardised next-command footer so the user
-    // always has a deterministic exit route.
+    process.stderr.write("If none of those look right, run `shrk help` or `shrk \"<task>\"` to route as a free-form task.\n");
     const footer = errorFooterFor('unknown-command', { task: attempted });
     if (footer)
         process.stderr.write(renderErrorFooter(footer));
 }
 // Entry point when invoked directly.
+//
+// Bun exposes `import.meta.main`; Node does not. When Node runs the
+// compiled `dist/main.js` directly the path-suffix check (`main.js`)
+// catches it. The npm bin shim points at `shrk` so that suffix also
+// triggers it. Source dev under Bun still runs via `main.ts`.
 const isMain = typeof import.meta !== 'undefined' && import.meta.main === true;
-if (isMain || process.argv[1]?.endsWith('main.ts') || process.argv[1]?.endsWith('shrk')) {
+const entryPath = process.argv[1] ?? '';
+if (isMain ||
+    entryPath.endsWith('main.ts') ||
+    entryPath.endsWith('main.js') ||
+    entryPath.endsWith('shrk') ||
+    entryPath.endsWith('shrk.js') ||
+    entryPath.endsWith('shrk.cmd')) {
     const argv = process.argv.slice(2);
     runCli(argv).then((code) => process.exit(code), (err) => {
         process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);

package/dist/output/failure-hints.d.ts

@@ -12,15 +12,7 @@ export interface IFailureHint {
     doc?: string;
 }
 export declare function renderFailureHints(hints: readonly IFailureHint[]): string;
-export interface IDoctorHintsContext {
-    /**
-     * True when the workspace has no `sharkcraft/` folder. On a fresh repo
-     * the right next step is `shrk init`, not advanced suppressions/watch
-     * loops.
-     */
-    sharkcraftFolderMissing?: boolean;
-}
-export declare function doctorHints(context?: IDoctorHintsContext): IFailureHint[];
+export declare function doctorHints(): IFailureHint[];
 export declare function staleKnowledgeHints(): IFailureHint[];
 export declare function templateDriftHints(): IFailureHint[];
 export declare function fuzzyImpactAmbiguousHints(): IFailureHint[];

package/dist/output/failure-hints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"failure-hints.d.ts","sourceRoot":"","sources":["../../src/output/failure-hints.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,yBAAyB;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAUzE;AAID,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED,wBAAgB,WAAW,CAAC,OAAO,GAAE,mBAAwB,GAAG,YAAY,EAAE,CAa7E;AAED,wBAAgB,mBAAmB,IAAI,YAAY,EAAE,CAMpD;AAED,wBAAgB,kBAAkB,IAAI,YAAY,EAAE,CAMnD;AAED,wBAAgB,yBAAyB,IAAI,YAAY,EAAE,CAK1D;AAED,wBAAgB,6BAA6B,IAAI,YAAY,EAAE,CAK9D;AAED,wBAAgB,kBAAkB,IAAI,YAAY,EAAE,CAKnD;AAED,wBAAgB,wBAAwB,IAAI,YAAY,EAAE,CAKzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAiB9D;AAED,MAAM,MAAM,eAAe,GACvB,iBAAiB,GACjB,mBAAmB,GACnB,gBAAgB,GAChB,oBAAoB,GACpB,uBAAuB,GACvB,kBAAkB,GAClB,eAAe,GACf,2BAA2B,GAC3B,sBAAsB,GACtB,+BAA+B,GAC/B,wBAAwB,GACxB,8BAA8B,CAAC;AAEnC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,GAAG,SAAS,CA4E3G"}
+{"version":3,"file":"failure-hints.d.ts","sourceRoot":"","sources":["../../src/output/failure-hints.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,yBAAyB;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAUzE;AAID,wBAAgB,WAAW,IAAI,YAAY,EAAE,CAM5C;AAED,wBAAgB,mBAAmB,IAAI,YAAY,EAAE,CAMpD;AAED,wBAAgB,kBAAkB,IAAI,YAAY,EAAE,CAMnD;AAED,wBAAgB,yBAAyB,IAAI,YAAY,EAAE,CAK1D;AAED,wBAAgB,6BAA6B,IAAI,YAAY,EAAE,CAK9D;AAED,wBAAgB,kBAAkB,IAAI,YAAY,EAAE,CAKnD;AAED,wBAAgB,wBAAwB,IAAI,YAAY,EAAE,CAKzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAiB9D;AAED,MAAM,MAAM,eAAe,GACvB,iBAAiB,GACjB,mBAAmB,GACnB,gBAAgB,GAChB,oBAAoB,GACpB,uBAAuB,GACvB,kBAAkB,GAClB,eAAe,GACf,2BAA2B,GAC3B,sBAAsB,GACtB,+BAA+B,GAC/B,wBAAwB,GACxB,8BAA8B,CAAC;AAEnC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,GAAG,SAAS,CA4E3G"}

package/dist/output/failure-hints.js

@@ -11,14 +11,8 @@ export function renderFailureHints(hints) {
     }
     return lines.join('\n') + '\n';
 }
-export function doctorHints(context = {}) {
-    if (context.sharkcraftFolderMissing) {
-        return [
-            { label: 'scaffold sharkcraft/ (auto-pick a preset)', command: 'shrk init --zero-config' },
-            { label: 'preview the scaffold first', command: 'shrk init --zero-config --dry-run' },
-            { label: 'try the killer demo (no folder required)', command: 'shrk check boundaries --changed-only --since main' },
-        ];
-    }
+// ── Convenience hint builders ──────────────────────────────────────────
+export function doctorHints() {
     return [
         { label: 'preview fix suggestions', command: 'shrk fix preview --action-hints' },
         { label: 'list suppressions', command: 'shrk doctor suppressions list' },

package/dist/output/watch-loop.d.ts

@@ -27,11 +27,19 @@ export interface IWatchPlan {
 }
 export declare function buildWatchPlan(options: IWatchLoopOptions, steps: readonly string[]): IWatchPlan;
 import type { ParsedArgs } from '../command-registry.js';
+export interface IWatchModeOptions {
+    /**
+     * Paths to watch when the user does not pass `--paths`. Defaults to
+     * `['sharkcraft']` if omitted. Use this for commands that scan code
+     * outside `sharkcraft/` (e.g. `check boundaries` scans the whole repo).
+     */
+    defaultPaths?: readonly string[];
+}
 /**
  * Run a command's `run` function inside a watch loop when --watch is set.
  *
  * @returns null if --watch is not set (caller proceeds as before), otherwise
  * the exit code of the watch loop.
  */
-export declare function maybeRunInWatchMode(args: ParsedArgs, runner: (innerArgs: ParsedArgs) => Promise<number>): Promise<number | null>;
+export declare function maybeRunInWatchMode(args: ParsedArgs, runner: (innerArgs: ParsedArgs) => Promise<number>, options?: IWatchModeOptions): Promise<number | null>;
 //# sourceMappingURL=watch-loop.d.ts.map

package/dist/output/watch-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch-loop.d.ts","sourceRoot":"","sources":["../../src/output/watch-loop.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,uCAAuC;IACvC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,4BAA4B;IAC5B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACvC;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA6DjB;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,0BAA0B,CAAC;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,UAAU,CAYZ;AAED,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,OAAO,CAAC,MAAM,CAAC,GACjD,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA0BxB"}
+{"version":3,"file":"watch-loop.d.ts","sourceRoot":"","sources":["../../src/output/watch-loop.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,uCAAuC;IACvC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,4BAA4B;IAC5B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACvC;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA6DjB;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,0BAA0B,CAAC;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,UAAU,CAYZ;AAED,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,OAAO,CAAC,MAAM,CAAC,EAClD,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAqCxB"}

package/dist/output/watch-loop.js

@@ -81,31 +81,41 @@ export function buildWatchPlan(options, steps) {
         steps,
     };
 }
-import { flagBool, flagNumber, resolveCwd } from "../command-registry.js";
+import { flagBool, flagNumber, flagString, resolveCwd } from "../command-registry.js";
 /**
  * Run a command's `run` function inside a watch loop when --watch is set.
  *
  * @returns null if --watch is not set (caller proceeds as before), otherwise
  * the exit code of the watch loop.
  */
-export async function maybeRunInWatchMode(args, runner) {
+export async function maybeRunInWatchMode(args, runner, options = {}) {
     if (!flagBool(args, 'watch'))
         return null;
     const cwd = resolveCwd(args);
     const debounce = flagNumber(args, 'debounce') ?? 300;
     const once = flagBool(args, 'once');
+    const pathsFlag = flagString(args, 'paths');
+    const userPaths = pathsFlag
+        ? pathsFlag.split(',').map((s) => s.trim()).filter((s) => s.length > 0)
+        : [];
+    const paths = userPaths.length > 0
+        ? userPaths
+        : options.defaultPaths && options.defaultPaths.length > 0
+            ? options.defaultPaths
+            : ['sharkcraft'];
     // Strip --watch so the inner snapshot doesn't recurse.
     const innerFlags = new Map(args.flags);
     innerFlags.delete('watch');
     innerFlags.delete('once');
     innerFlags.delete('debounce');
+    innerFlags.delete('paths');
     const innerArgs = {
         positional: args.positional,
         flags: innerFlags,
         multiFlags: args.multiFlags,
         ...(args.globalCwd ? { globalCwd: args.globalCwd } : {}),
     };
-    return runWatchLoop({ cwd, debounce, once }, {
+    return runWatchLoop({ cwd, debounce, once, paths }, {
         snapshot: async () => {
             const ts = new Date().toLocaleTimeString();
             process.stdout.write(`\n[watch] ${ts}\n`);