@shrkcrft/cli 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/output/output-compression.js

@@ -0,0 +1,60 @@
+import { spawnSync } from 'node:child_process';
+import { compressContent } from '@shrkcrft/compress';
+import { openCcrStore } from "./ccr-store-config.js";
+import { resolveCompressType } from "./resolve-compress-type.js";
+// Command output can be large (a full knowledge dump, a wide graph). Allow up to
+// 64 MiB of captured stdout before spawnSync gives up.
+const MAX_BUFFER = 64 * 1024 * 1024;
+/**
+ * Implements the global `--compress` / `--ccr` flag: run a `shrk` command in a
+ * child process, capture its stdout, and emit a deterministically-compressed
+ * version (with the original cached for `shrk expand`). The command's own
+ * stderr is forwarded verbatim and its exit code is preserved.
+ *
+ * A SUBPROCESS (not in-process `process.stdout` capture) on purpose: some
+ * commands call `process.exit`, which would discard a buffered in-process
+ * capture mid-write; re-running the command isolates that and still yields the
+ * full output + real exit status. `childArgv` has already had the compress
+ * flags stripped, so the child never recurses.
+ */
+export function runCommandWithCompression(childArgv, directive, cwd) {
+    const runtime = process.argv[0];
+    const entry = process.argv[1];
+    if (!runtime || !entry) {
+        process.stderr.write('--compress: cannot determine the shrk entry point to re-run; emitting uncompressed.\n');
+        return 1;
+    }
+    // Resolve an explicit --compress-type up front so a typo is reported loudly
+    // (not silently auto-detected), even if the command ends up printing nothing.
+    const resolvedType = resolveCompressType(directive.type);
+    if (resolvedType.warning)
+        process.stderr.write(`${resolvedType.warning}\n`);
+    const res = spawnSync(runtime, [entry, ...childArgv], {
+        encoding: 'utf8',
+        maxBuffer: MAX_BUFFER,
+        env: process.env,
+    });
+    if (res.error) {
+        process.stderr.write(`--compress: failed to run the command (${res.error.message}); emitting nothing.\n`);
+        return 1;
+    }
+    // Forward the command's own stderr (warnings, summaries, errors) untouched.
+    if (res.stderr)
+        process.stderr.write(res.stderr);
+    const captured = res.stdout ?? '';
+    const code = res.status ?? (res.signal ? 1 : 0);
+    // Nothing on stdout (or the command failed) → don't fabricate output.
+    if (captured.length === 0)
+        return code;
+    const opts = { store: openCcrStore(cwd) };
+    if (directive.query)
+        opts.query = directive.query;
+    if (resolvedType.type)
+        opts.contentType = resolvedType.type;
+    const result = compressContent(captured, opts);
+    process.stdout.write(result.compressed.endsWith('\n') ? result.compressed : `${result.compressed}\n`);
+    const pct = Math.round(result.savings.ratio * 100);
+    const cached = result.ccrKey ? ` · original cached (shrk expand ${result.ccrKey})` : '';
+    process.stderr.write(`[--compress] ${result.strategy}: ~${result.savings.before} → ~${result.savings.after} tokens (−${pct}%, est.)${cached}\n`);
+    return code;
+}

package/dist/output/resolve-compress-type.d.ts

@@ -0,0 +1,22 @@
+import { EContentType } from '@shrkcrft/compress';
+/** Outcome of resolving a raw `--compress-type` string. */
+export interface IResolvedCompressType {
+    /** The forced content type — set only when the raw value named a valid one. */
+    type?: EContentType;
+    /**
+     * A user-facing warning, set when the raw value was non-empty but
+     * unrecognized. The caller surfaces it (on stderr) so an explicit-but-typo'd
+     * `--compress-type` is reported rather than silently dropped.
+     */
+    warning?: string;
+}
+/**
+ * Resolve a raw `--compress-type` flag value into a forced {@link EContentType}.
+ *
+ * An unrecognized, non-empty value is NOT silently ignored (the old behavior):
+ * it yields a `warning` listing the valid types, so the caller can tell the
+ * user their explicit choice was dropped before falling back to auto-detection.
+ * A missing or empty value is a no-op (auto-detect, no warning).
+ */
+export declare function resolveCompressType(raw: string | undefined): IResolvedCompressType;
+//# sourceMappingURL=resolve-compress-type.d.ts.map

package/dist/output/resolve-compress-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-compress-type.d.ts","sourceRoot":"","sources":["../../src/output/resolve-compress-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKlD,2DAA2D;AAC3D,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,qBAAqB,CAOlF"}

package/dist/output/resolve-compress-type.js

@@ -0,0 +1,21 @@
+import { EContentType } from '@shrkcrft/compress';
+/** The valid `--compress-type` values: the EContentType wire strings. */
+const VALID_TYPES = new Set(Object.values(EContentType));
+/**
+ * Resolve a raw `--compress-type` flag value into a forced {@link EContentType}.
+ *
+ * An unrecognized, non-empty value is NOT silently ignored (the old behavior):
+ * it yields a `warning` listing the valid types, so the caller can tell the
+ * user their explicit choice was dropped before falling back to auto-detection.
+ * A missing or empty value is a no-op (auto-detect, no warning).
+ */
+export function resolveCompressType(raw) {
+    if (raw === undefined || raw === '')
+        return {};
+    if (VALID_TYPES.has(raw))
+        return { type: raw };
+    const valid = [...VALID_TYPES].sort().join(', ');
+    return {
+        warning: `--compress: unknown --compress-type "${raw}"; auto-detecting instead. Valid types: ${valid}.`,
+    };
+}

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`);