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

package/dist/commands/move-plan.command.js

@@ -0,0 +1,360 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { GraphQueryApi, GraphStore } from '@shrkcrft/graph';
+import { flagBool, resolveCwd } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+/**
+ * `shrk move-plan <source> <target>` — emit a structured plan for
+ * moving a source file to a new location. Read-only: NEVER moves
+ * anything itself, never rewrites imports. The agent (or a human)
+ * uses the plan to do the actual work.
+ *
+ * Covers:
+ *   - graph-traced importer rewrites (relative + package-name imports)
+ *   - exports to revisit if the source was re-exported from an index
+ *   - cross-package warnings (layer-order risks)
+ *   - a rollback plan that's the literal reverse of the move
+ *   - validation commands to run after applying
+ *
+ * Limitations:
+ *   - single-file only. Directory moves can be approximated by
+ *     listing the directory and running this command per file, or
+ *     wait for a `--folder` follow-up.
+ *   - `from '@shrkcrft/pkg/sub'` deep-import rewrites are best-effort;
+ *     ambiguous cases get reported as `review-manually`.
+ */
+export const movePlanCommand = {
+    name: 'move-plan',
+    description: 'Plan a file move: graph-traced importer rewrites, export touch-ups, cross-package warnings. Read-only.',
+    usage: 'shrk move-plan <source-file> <target-file> [--json]',
+    async run(args) {
+        const sourceArg = args.positional[0]?.trim();
+        const targetArg = args.positional[1]?.trim();
+        if (!sourceArg || !targetArg) {
+            process.stderr.write('Usage: shrk move-plan <source-file> <target-file> [--json]\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const json = flagBool(args, 'json');
+        const sourceRel = relativize(cwd, sourceArg);
+        const targetRel = relativize(cwd, targetArg);
+        if (!existsSync(nodePath.join(cwd, sourceRel))) {
+            process.stderr.write(`Source file does not exist: ${sourceRel}\n`);
+            return 1;
+        }
+        if (existsSync(nodePath.join(cwd, targetRel))) {
+            process.stderr.write(`Target already exists (won't propose moving on top of it): ${targetRel}\n`);
+            return 1;
+        }
+        const store = new GraphStore(cwd);
+        if (!store.exists()) {
+            process.stderr.write('No SharkCraft graph found. Run `shrk graph index` so move-plan can trace importers.\n');
+            return 1;
+        }
+        const api = GraphQueryApi.fromStore(cwd);
+        const sourcePackage = resolveOwningPackage(cwd, sourceRel);
+        const targetPackage = resolveOwningPackage(cwd, targetRel);
+        const crossesPackages = sourcePackage?.name !== targetPackage?.name;
+        const importerNodes = (() => {
+            const fileNode = api.findFile(sourceRel);
+            if (!fileNode)
+                return [];
+            return api.importersOf(fileNode.id)
+                .map((n) => n.path)
+                .filter((p) => typeof p === 'string' && p.length > 0);
+        })();
+        const importsToRewrite = [];
+        const exportsToUpdate = [];
+        for (const importerPath of importerNodes) {
+            const abs = nodePath.join(cwd, importerPath);
+            if (!existsSync(abs))
+                continue;
+            let body;
+            try {
+                body = readFileSync(abs, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const rewrites = computeRewritesForFile({
+                importerPath,
+                importerBody: body,
+                sourceRel,
+                targetRel,
+                sourcePackage,
+                targetPackage,
+            });
+            importsToRewrite.push(...rewrites);
+            // If the importer is `<pkg>/src/index.ts` and re-exports the source,
+            // it likely needs to drop / move that export.
+            if (/(^|\/)index\.[jt]sx?$/.test(importerPath) && body.includes(sourceBaseSpecifier(sourceRel))) {
+                exportsToUpdate.push({
+                    file: importerPath,
+                    action: 'review-manually',
+                    reason: `index file re-exports something from "${sourceRel}"; relocate the re-export to point at "${targetRel}" or drop it.`,
+                });
+            }
+        }
+        // Also check if the source file itself is referenced from its own
+        // package's index.ts.
+        if (sourcePackage) {
+            const sourceIndex = nodePath.join(cwd, sourcePackage.dir, 'src/index.ts');
+            const sourceIndexRel = nodePath.relative(cwd, sourceIndex);
+            const alreadyFlagged = exportsToUpdate.some((e) => e.file === sourceIndexRel);
+            if (!alreadyFlagged && existsSync(sourceIndex)) {
+                try {
+                    const body = readFileSync(sourceIndex, 'utf8');
+                    if (body.includes(sourceBaseSpecifier(sourceRel))) {
+                        exportsToUpdate.push({
+                            file: sourceIndexRel,
+                            action: 'edit',
+                            reason: crossesPackages
+                                ? `index re-exports the moved file; drop the export (the file now lives in another package) or replace with a forwarding re-export.`
+                                : `index re-exports the moved file; update the relative path to point at the new location.`,
+                        });
+                    }
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+        const affectedPackages = unique([
+            ...importerNodes.map((p) => resolveOwningPackage(cwd, p)?.name ?? null),
+            sourcePackage?.name ?? null,
+            targetPackage?.name ?? null,
+        ].filter((n) => typeof n === 'string'));
+        const risks = [];
+        if (crossesPackages) {
+            risks.push(`Cross-package move: ${sourcePackage?.name ?? '(no package)'} → ${targetPackage?.name ?? '(no package)'}. Run \`shrk check boundaries\` after the move to confirm the new home is layered correctly.`);
+        }
+        if (importerNodes.length > 30) {
+            risks.push(`${importerNodes.length} importer(s) — large blast radius. Consider scripting the rewrites or moving in smaller chunks.`);
+        }
+        if (exportsToUpdate.some((e) => e.action === 'review-manually')) {
+            risks.push('Some index re-exports were flagged for manual review — automatic rewriting could lose intent.');
+        }
+        const movePlan = [
+            {
+                order: 1,
+                title: 'Move the file',
+                details: `git mv "${sourceRel}" "${targetRel}"  (then verify content unchanged)`,
+            },
+            ...importsToRewrite.map((rw, i) => ({
+                order: 2 + i,
+                title: `Rewrite import in ${rw.file}`,
+                details: `Replace \`from '${rw.fromImport}'\` with \`from '${rw.toImport}'\`. Reason: ${rw.reason}`,
+            })),
+            ...(exportsToUpdate.length > 0
+                ? [
+                    {
+                        order: 2 + importsToRewrite.length,
+                        title: 'Reconcile index re-exports',
+                        details: exportsToUpdate
+                            .map((e) => `${e.file} (${e.action}): ${e.reason}`)
+                            .join('  ||  '),
+                    },
+                ]
+                : []),
+        ];
+        const rollbackPlan = [
+            { order: 1, title: 'Restore file', details: `git mv "${targetRel}" "${sourceRel}"` },
+            {
+                order: 2,
+                title: 'Revert import rewrites',
+                details: importsToRewrite.length === 0
+                    ? 'No importers to revert.'
+                    : `git restore ${unique(importsToRewrite.map((r) => r.file)).join(' ')}`,
+            },
+        ];
+        const validationCommands = [
+            'bun x tsc -p tsconfig.base.json --noEmit',
+            'shrk check boundaries',
+            'shrk check imports',
+            'bun test',
+        ];
+        const status = importsToRewrite.length === 0 && exportsToUpdate.length === 0
+            ? 'no-importers'
+            : crossesPackages
+                ? 'cross-package'
+                : 'in-package';
+        const handoff = status === 'no-importers'
+            ? `Move is trivial — no importers reference "${sourceRel}". Just run the file move + validation.`
+            : status === 'cross-package'
+                ? `Move crosses packages. Apply each importsToRewrite[] edit, then revisit exportsToUpdate[], then run validationCommands. Re-run \`shrk check boundaries\` to confirm layering.`
+                : `In-package move with ${importsToRewrite.length} importer rewrite(s). Safe but worth applying mechanically.`;
+        const report = {
+            schema: 'sharkcraft.move-plan/v1',
+            source: { path: sourceRel, package: sourcePackage?.name ?? null },
+            target: { path: targetRel, package: targetPackage?.name ?? null },
+            crossesPackages,
+            movePlan,
+            importsToRewrite,
+            exportsToUpdate,
+            affectedPackages,
+            risks,
+            rollbackPlan,
+            validationCommands,
+            handoffForClaude: handoff,
+        };
+        if (json) {
+            process.stdout.write(asJson(report) + '\n');
+            return 0;
+        }
+        renderText(report);
+        return 0;
+    },
+};
+function relativize(cwd, raw) {
+    const cleaned = raw.replace(/\\/g, '/').replace(/^\.\//, '');
+    if (nodePath.isAbsolute(cleaned)) {
+        return nodePath.relative(cwd, cleaned).replace(/\\/g, '/');
+    }
+    return cleaned;
+}
+const PACKAGE_CACHE = new Map();
+function listPackages(cwd) {
+    const cached = PACKAGE_CACHE.get(cwd);
+    if (cached)
+        return cached;
+    const out = [];
+    for (const root of ['packages', 'libs', 'apps']) {
+        const rootAbs = nodePath.join(cwd, root);
+        if (!existsSync(rootAbs))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(rootAbs);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const dir = nodePath.join(root, entry);
+            const pkgJson = nodePath.join(cwd, dir, 'package.json');
+            if (!existsSync(pkgJson))
+                continue;
+            try {
+                const parsed = JSON.parse(readFileSync(pkgJson, 'utf8'));
+                if (parsed.name)
+                    out.push({ name: parsed.name, dir });
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+    PACKAGE_CACHE.set(cwd, out);
+    return out;
+}
+function resolveOwningPackage(cwd, fileRel) {
+    const packages = listPackages(cwd);
+    let best = null;
+    for (const p of packages) {
+        const dirSlash = p.dir.replace(/\\/g, '/') + '/';
+        if (fileRel.startsWith(dirSlash)) {
+            if (!best || p.dir.length > best.dir.length)
+                best = p;
+        }
+    }
+    return best;
+}
+function sourceBaseSpecifier(sourceRel) {
+    // The plain basename without extension — usable as a fuzzy substring
+    // match against `from '../foo'` re-exports.
+    const ext = nodePath.extname(sourceRel);
+    return nodePath.basename(sourceRel, ext);
+}
+function computeRewritesForFile(input) {
+    const out = [];
+    const seen = new Set();
+    const importerDir = nodePath.dirname(input.importerPath);
+    const expectedRelativeBefore = toRelativeSpecifier(importerDir, input.sourceRel);
+    const expectedRelativeAfter = toRelativeSpecifier(importerDir, input.targetRel);
+    // Pattern 1: relative imports that resolve to the source file.
+    // Try both with-extension and without-extension forms.
+    const candidates = [expectedRelativeBefore, stripJsTsExt(expectedRelativeBefore)];
+    for (const cand of candidates) {
+        if (cand.length === 0)
+            continue;
+        if (!input.importerBody.includes(`'${cand}'`) && !input.importerBody.includes(`"${cand}"`))
+            continue;
+        const targetCand = stripJsTsExt(expectedRelativeAfter);
+        const key = `rel:${cand}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({
+            file: input.importerPath,
+            fromImport: cand,
+            toImport: targetCand,
+            reason: 'relative-path rewrite (importer-relative)',
+        });
+    }
+    // Pattern 2: package-name imports `@shrkcrft/xxx` when the source is
+    // inside that package and the target is in a different one.
+    if (input.sourcePackage && input.targetPackage && input.sourcePackage.name !== input.targetPackage.name) {
+        const fromSpec = input.sourcePackage.name;
+        const toSpec = input.targetPackage.name;
+        if ((input.importerBody.includes(`'${fromSpec}'`) || input.importerBody.includes(`"${fromSpec}"`)) &&
+            // and the package-name import is actually exposing the moved symbol
+            // (we can't know for sure without re-resolving — flag as review).
+            input.importerPath !== fromIndexPath(input.sourcePackage)) {
+            const key = `pkg:${fromSpec}->${toSpec}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                out.push({
+                    file: input.importerPath,
+                    fromImport: fromSpec,
+                    toImport: toSpec,
+                    reason: 'package-name import: importer likely consumes the symbol via the old package. Verify the target package re-exports the symbol from its public index before applying.',
+                });
+            }
+        }
+    }
+    return out;
+}
+function fromIndexPath(pkg) {
+    return nodePath.join(pkg.dir, 'src/index.ts');
+}
+function toRelativeSpecifier(fromDir, toRel) {
+    const rel = nodePath.relative(fromDir, toRel).replace(/\\/g, '/');
+    if (!rel.startsWith('.'))
+        return `./${rel}`;
+    return rel;
+}
+function stripJsTsExt(p) {
+    return p.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, '');
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function renderText(r) {
+    process.stdout.write(header(`move-plan: ${r.source.path} → ${r.target.path}${r.crossesPackages ? ' (cross-package)' : ''}`));
+    process.stdout.write(`affected packages: ${r.affectedPackages.join(', ') || '(none)'}\n\n`);
+    process.stdout.write(`move plan (${r.movePlan.length} step(s)):\n`);
+    for (const s of r.movePlan) {
+        process.stdout.write(`  ${s.order}. ${s.title} — ${s.details}\n`);
+    }
+    if (r.importsToRewrite.length > 0) {
+        process.stdout.write(`\nimport rewrites (${r.importsToRewrite.length}):\n`);
+        for (const rw of r.importsToRewrite) {
+            process.stdout.write(`  ${rw.file}\n    from '${rw.fromImport}' → to '${rw.toImport}'\n    (${rw.reason})\n`);
+        }
+    }
+    if (r.exportsToUpdate.length > 0) {
+        process.stdout.write('\nexports to update:\n');
+        for (const e of r.exportsToUpdate) {
+            process.stdout.write(`  ${e.file} [${e.action}] — ${e.reason}\n`);
+        }
+    }
+    if (r.risks.length > 0) {
+        process.stdout.write('\nrisks:\n');
+        for (const r2 of r.risks)
+            process.stdout.write(`  - ${r2}\n`);
+    }
+    process.stdout.write('\nvalidation commands:\n');
+    for (const c of r.validationCommands)
+        process.stdout.write(`  $ ${c}\n`);
+    process.stdout.write(`\nhandoff: ${r.handoffForClaude}\n`);
+}

package/dist/commands/packs-new.d.ts

@@ -1,5 +1,5 @@
 import { type ICommandHandler } from '../command-registry.js';
-export type PackKind = 'generic' | 'framework' | 'architecture' | 'enterprise' | 'platform-adopter';
+export type PackKind = 'generic' | 'framework' | 'architecture' | 'enterprise';
 interface IScaffoldFile {
     /** Path relative to the new pack root. */
     relativePath: string;

package/dist/commands/packs-new.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packs-new.d.ts","sourceRoot":"","sources":["../../src/commands/packs-new.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,GAAG,YAAY,GAAG,kBAAkB,CAAC;AAUpG,UAAU,aAAa;IACrB,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,CA+G/E;AA4TD,eAAO,MAAM,eAAe,EAAE,eAoG7B,CAAC;AAUF,eAAO,MAAM,gBAAgB,EAAE,eAqI9B,CAAC"}
+{"version":3,"file":"packs-new.d.ts","sourceRoot":"","sources":["../../src/commands/packs-new.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,GAAG,YAAY,CAAC;AAS/E,UAAU,aAAa;IACrB,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,CAyG/E;AA0SD,eAAO,MAAM,eAAe,EAAE,eAoG7B,CAAC;AAUF,eAAO,MAAM,gBAAgB,EAAE,eAqI9B,CAAC"}

package/dist/commands/packs-new.js

@@ -1,21 +1,13 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import * as nodePath from 'node:path';
 import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
 import { asJson, header, kv } from "../output/format-output.js";
+import { importModuleViaLoader } from '@shrkcrft/core';
 const VALID_KINDS = new Set([
     'generic',
     'framework',
     'architecture',
     'enterprise',
-    'platform-adopter',
 ]);
 /** Pure: compute the file set to write. No IO. */
 export function planPackScaffold(input) {
@@ -108,12 +100,6 @@ export function planPackScaffold(input) {
             body: renderBoundariesAsset(),
         });
     }
-    if (input.kind === 'platform-adopter' || input.withExamples) {
-        files.push({
-            relativePath: 'src/assets/contracts/plugin-contract.example.ts',
-            body: renderPluginContractExample(),
-        });
-    }
     if (input.kind === 'enterprise') {
         files.push({
             relativePath: 'docs/review-workflow.md',
@@ -239,12 +225,6 @@ function renderKnowledgeAsset(input) {
             ['framework.overview', 'Framework overview', 'High', 'What this framework is for.'],
         ]);
     }
-    if (input.kind === 'platform-adopter') {
-        return knowledgeBody([
-            ['platform.policy', 'Policy capability', 'Medium', 'Describe the policy/capability model your platform exposes.'],
-            ['platform.adapter', 'Adapter contract', 'Medium', 'Describe the adapter contract your platform expects.'],
-        ]);
-    }
     return knowledgeBody([
         ['pack.overview', 'Pack overview', 'Medium', 'Short overview of what this pack contributes.'],
     ]);
@@ -357,17 +337,6 @@ function renderBoundariesAsset() {
         ``,
     ].join('\n');
 }
-function renderPluginContractExample() {
-    return [
-        `// Example: an adapter-style plugin contract.`,
-        `// Replace with the actual interface your platform expects.`,
-        `export interface IPluginCapability {`,
-        `  id: string;`,
-        `  invoke(input: unknown): Promise<unknown>;`,
-        `}`,
-        ``,
-    ].join('\n');
-}
 function renderEnterpriseReviewDocs() {
     return [
         `# Review workflow`,
@@ -414,11 +383,11 @@ function renderDocsOverview(input, fullName) {
 export const packsNewCommand = {
     name: 'new',
     description: 'Scaffold a new SharkCraft pack package (rules / paths / templates / pipelines / presets / boundaries). Dry-run by default — pass --write to materialize. No install, no publish, no overwrite without --force.',
-    usage: 'shrk [--cwd <dir>] packs new <name> [--scope @org] [--preset <id>] [--kind generic|framework|architecture|enterprise|platform-adopter] [--with-examples] [--write] [--force] [--json]',
+    usage: 'shrk [--cwd <dir>] packs new <name> [--scope @org] [--preset <id>] [--kind generic|framework|architecture|enterprise] [--with-examples] [--write] [--force] [--json]',
     async run(args) {
         const name = args.positional[0];
         if (!name) {
-            process.stderr.write('Usage: shrk packs new <name> [--scope @org] [--preset <id>] [--kind generic|framework|architecture|enterprise|platform-adopter] [--with-examples] [--write]\n');
+            process.stderr.write('Usage: shrk packs new <name> [--scope @org] [--preset <id>] [--kind generic|framework|architecture|enterprise] [--with-examples] [--write]\n');
             return 2;
         }
         const cwd = resolveCwd(args);
@@ -645,7 +614,7 @@ async function runRuntimePackTest(input) {
     if (existsSync(entry)) {
         try {
             const { pathToFileURL } = await import('node:url');
-            const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(entry).href + `?bust=${Date.now()}`)));
+            const mod = (await importModuleViaLoader(entry));
             const value = mod.default ?? mod;
             const shape = describeShape(value);
             modules.push({
@@ -692,7 +661,7 @@ async function runRuntimePackTest(input) {
             continue;
         try {
             const { pathToFileURL } = await import('node:url');
-            const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(full).href + `?bust=${Date.now()}`)));
+            const mod = (await importModuleViaLoader(full));
             const value = mod.default;
             const arr = Array.isArray(value) ? value : null;
             modules.push({

package/dist/commands/packs.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packs.command.d.ts","sourceRoot":"","sources":["../../src/commands/packs.command.ts"],"names":[],"mappings":"AAqBA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAOhC,eAAO,MAAM,yBAAyB,EAAE,eAoCvC,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,eAsGzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eA+CnC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAuD9B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAsE7B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAqDjC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAyFhC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAqEhC,CAAC;AA4DF,eAAO,MAAM,gBAAgB,EAAE,eA+K9B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAmCtC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAmFhC,CAAC;AAMF,eAAO,MAAM,qBAAqB,EAAE,eA4BnC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eA+E/B,CAAC"}
+{"version":3,"file":"packs.command.d.ts","sourceRoot":"","sources":["../../src/commands/packs.command.ts"],"names":[],"mappings":"AAoBA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAQhC,eAAO,MAAM,yBAAyB,EAAE,eAoCvC,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,eAsGzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eA+CnC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAuD9B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAsE7B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAqDjC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAyFhC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAqEhC,CAAC;AA4DF,eAAO,MAAM,gBAAgB,EAAE,eA+K9B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAmCtC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAmFhC,CAAC;AAMF,eAAO,MAAM,qBAAqB,EAAE,eA4BnC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eA+E/B,CAAC"}

package/dist/commands/packs.command.js

@@ -1,18 +1,10 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import * as nodePath from 'node:path';
-import { pathToFileURL } from 'node:url';
 import { buildPackDoctorReport, buildPackSignatureStatusReport, checkPackSymbolCompat, explainPackSignatureStatus, inspectSharkcraft, mergePackReleaseChecks, runPackReleaseCheck, runPackReleaseChecksForReport, } from '@shrkcrft/inspector';
 import { PACK_SECRET_ENV, signPackManifest, validatePackManifest, verifyPackManifest, } from '@shrkcrft/plugin-api';
 import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
 import { asJson, header, kv } from "../output/format-output.js";
+import { importModuleViaLoader } from '@shrkcrft/core';
 function statusLabel(valid) {
     return valid ? 'OK     ' : 'INVALID';
 }
@@ -553,7 +545,7 @@ async function loadManifestFromPath(manifestPath) {
     if (manifestPath.endsWith('.json')) {
         return JSON.parse(readFileSync(manifestPath, 'utf8'));
     }
-    const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(manifestPath).href)));
+    const mod = (await importModuleViaLoader(manifestPath));
     return (mod.default ?? mod);
 }
 export const packsSignCommand = {

package/dist/commands/plan-context.command.d.ts

@@ -0,0 +1,11 @@
+import { type ICommandHandler } from '../command-registry.js';
+/**
+ * `shrk plan-context` — produce a deterministic, token-budgeted context
+ * pack for an AI coding agent. Reads the code graph + (optionally) the
+ * rule-graph bridge.
+ *
+ * Read-only. The pack is whatever the planner decides; the agent uses
+ * it as the starting point for its conversation.
+ */
+export declare const planContextCommand: ICommandHandler;
+//# sourceMappingURL=plan-context.command.d.ts.map

package/dist/commands/plan-context.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-context.command.d.ts","sourceRoot":"","sources":["../../src/commands/plan-context.command.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAsEhC,CAAC"}

package/dist/commands/plan-context.command.js

@@ -0,0 +1,85 @@
+import { planContext } from '@shrkcrft/context-planner';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+/**
+ * `shrk plan-context` — produce a deterministic, token-budgeted context
+ * pack for an AI coding agent. Reads the code graph + (optionally) the
+ * rule-graph bridge.
+ *
+ * Read-only. The pack is whatever the planner decides; the agent uses
+ * it as the starting point for its conversation.
+ */
+export const planContextCommand = {
+    name: 'plan-context',
+    description: 'Produce a deterministic, token-budgeted context pack (`sharkcraft.context-pack/v1`) for an AI agent: ranked files, likely tests, and (shallow) surfaced risks / do-not-touch zones. Rules/paths/templates require the rule-graph bridge (`shrk rule-graph index`); the pack reports per-field `coverage` so empty sections are distinguishable from not-computed ones.',
+    usage: 'shrk plan-context "<task>" [--budget N] [--max-files N] [--hint-file <path>] [--hint-package <prefix>] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const wantJson = flagBool(args, 'json');
+        const task = args.positional[0];
+        if (!task) {
+            process.stderr.write(this.usage + '\n');
+            return 2;
+        }
+        const budget = Number(flagString(args, 'budget') ?? '8000');
+        const maxFiles = Number(flagString(args, 'max-files') ?? '30');
+        const hintedFiles = collectMulti(args, 'hint-file');
+        const hintedPackages = collectMulti(args, 'hint-package');
+        const pack = planContext({
+            projectRoot: cwd,
+            task,
+            budgetTokens: budget,
+            maxFiles,
+            ...(hintedFiles.length > 0 ? { hintedFiles } : {}),
+            ...(hintedPackages.length > 0 ? { hintedPackages } : {}),
+        });
+        if (wantJson) {
+            process.stdout.write(asJson(pack) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Context pack: ${task}`));
+        process.stdout.write(kv('intent', pack.intent) + '\n');
+        process.stdout.write(kv('files', String(pack.files.length)) + '\n');
+        // Distinguish "computed, none apply" from "not computed". When the bridge
+        // is missing, rules/paths/templates are omitted, not empty — say so rather
+        // than printing a misleading `0`.
+        if (pack.coverage.rulesComputed) {
+            process.stdout.write(kv('rules', String(pack.rules.length)) + '\n');
+            process.stdout.write(kv('paths', String(pack.paths.length)) + '\n');
+            process.stdout.write(kv('templates', String(pack.templates.length)) + '\n');
+        }
+        else {
+            process.stdout.write(kv('rules/paths/templates', 'not computed (run `shrk rule-graph index`)') + '\n');
+        }
+        process.stdout.write(kv('tests', String(pack.tests.length)) + '\n');
+        process.stdout.write(kv('risks', pack.coverage.risksComputed ? String(pack.risks.length) : 'not computed') + '\n');
+        process.stdout.write(kv('budget', `${pack.budget.used}/${pack.budget.requested} tokens` + (pack.budget.truncated ? ' (truncated)' : '')) + '\n');
+        if (pack.files.length > 0) {
+            process.stdout.write('\nTop files:\n');
+            for (const f of pack.files.slice(0, 15)) {
+                const reason = f.reasons[0] ? `  [${f.reasons[0]}]` : '';
+                process.stdout.write(`  ${f.score.toFixed(2)}  ${f.path}${reason}\n`);
+            }
+        }
+        if (pack.tests.length > 0) {
+            process.stdout.write('\nLikely tests:\n');
+            for (const t of pack.tests.slice(0, 5))
+                process.stdout.write(`  ${t}\n`);
+        }
+        if (pack.risks.length > 0) {
+            process.stdout.write('\nRisks:\n');
+            for (const r of pack.risks)
+                process.stdout.write(`  • [${r.kind}] ${r.label}\n`);
+        }
+        for (const d of pack.diagnostics.slice(0, 5))
+            process.stdout.write(`! ${d}\n`);
+        return 0;
+    },
+};
+function collectMulti(args, name) {
+    const list = args.multiFlags.get(name);
+    if (list)
+        return [...list];
+    const single = flagString(args, name);
+    return single ? [single] : [];
+}

package/dist/commands/preflight.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preflight.command.d.ts","sourceRoot":"","sources":["../../src/commands/preflight.command.ts"],"names":[],"mappings":"AAoBA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAgBhC,eAAO,MAAM,gBAAgB,EAAE,eAmF9B,CAAC"}
+{"version":3,"file":"preflight.command.d.ts","sourceRoot":"","sources":["../../src/commands/preflight.command.ts"],"names":[],"mappings":"AAoBA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAiBhC,eAAO,MAAM,gBAAgB,EAAE,eAoG9B,CAAC"}

package/dist/commands/preflight.command.js

@@ -13,6 +13,7 @@
  */
 import { planChangedPreflight, PreflightAction, PreflightProfile, renderChangedPreflightText, resolveChangedFiles, } from '@shrkcrft/inspector';
 import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { loadProjectConfig } from '@shrkcrft/config';
 import { asJson, header } from "../output/format-output.js";
 function parseProfile(value) {
     if (value === 'quick')
@@ -55,10 +56,24 @@ export const preflightCommand = {
             resolveOpts.includeWorktree = true;
         }
         const changed = resolveChangedFiles(resolveOpts);
+        // Ground the test/typecheck gates in the project's declared verification
+        // commands when present, rather than the generic `bun test` / tsc defaults.
+        // Best-effort: a repo without sharkcraft/ config keeps the defaults.
+        let testCommand;
+        let typecheckCommand;
+        const loaded = await loadProjectConfig(cwd);
+        if (loaded.ok) {
+            const vcs = loaded.value.config.verificationCommands ?? [];
+            const pick = (...ids) => vcs.find((v) => ids.includes(v.id))?.command;
+            testCommand = pick('test', 'tests', 'unit', 'unit-tests');
+            typecheckCommand = pick('typecheck', 'tsc', 'types', 'typecheck-all');
+        }
         const plan = planChangedPreflight({
             projectRoot: cwd,
             changedFiles: changed.files,
             profile,
+            ...(testCommand ? { testCommand } : {}),
+            ...(typecheckCommand ? { typecheckCommand } : {}),
         });
         if (flagBool(args, 'json')) {
             process.stdout.write(asJson({ plan, scopeMode: changed.mode }) + '\n');