rahman-resources 1.13.3 → 1.14.1

package/bin/cli.js

@@ -167,6 +167,10 @@ ${kleur.dim("Consumer's components/ui/ + lib/utils.ts (shadcn) are never touched
 
 // ─── flag parsing ─────────────────────────────────────────────────────────
 
+// Flags that take a value (`--flag x`). Anything else is boolean, so a boolean
+// flag placed before a positional no longer swallows that positional.
+const VALUE_FLAGS = new Set(["target", "template", "category", "at", "skills", "features"]);
+
 function parseFlags(rest) {
   const positional = [];
   const flags = {};
@@ -175,7 +179,7 @@ function parseFlags(rest) {
     if (a.startsWith("--")) {
       const key = a.slice(2);
       const next = rest[i + 1];
-      if (next && !next.startsWith("--")) { flags[key] = next; i++; }
+      if (VALUE_FLAGS.has(key) && next && !next.startsWith("--")) { flags[key] = next; i++; }
       else flags[key] = true;
     } else {
       positional.push(a);

package/bin/migrate-load.mjs

@@ -8,6 +8,10 @@
 import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import path from "node:path";
+import { loadSliceContract } from "../lib/load-contract.mjs";
+
+// Flags that take a value; anything else is boolean (mirrors cli.js parseFlags).
+const VALUE_FLAGS = new Set(["from", "to", "repo-root"]);
 
 export function parseFlags(rest) {
   const positional = [];
@@ -17,7 +21,7 @@ export function parseFlags(rest) {
     if (a.startsWith("--")) {
       const key = a.slice(2);
       const next = rest[i + 1];
-      if (next && !next.startsWith("--")) {
+      if (VALUE_FLAGS.has(key) && next && !next.startsWith("--")) {
         flags[key] = next;
         i++;
       } else {
@@ -51,26 +55,32 @@ const SLICE_ROOTS = [
   ["template-base", "frontend", "slices"],
 ];
 
-function resolveContractPath(repoRoot, slug) {
+// The CURRENT contract is folded into slice.json — locate the slice dir by its
+// slice.json (the .ts no longer exists in the working tree post-cutover).
+function resolveSliceDir(repoRoot, slug) {
   for (const segs of SLICE_ROOTS) {
-    const p = path.join(repoRoot, ...segs, slug, "slice.contract.ts");
-    if (existsSync(p)) return p;
+    const dir = path.join(repoRoot, ...segs, slug);
+    if (existsSync(path.join(dir, "slice.json"))) return dir;
   }
   return null;
 }
 
+// HISTORIC leg still pulls the OLD slice.contract.ts from git history, so the
+// rel path is the .ts path — but gate on the slice's slice.json existing today
+// (NOT the working-tree .ts, which is gone post-cutover).
 function resolveContractRelPath(repoRoot, slug) {
   for (const segs of SLICE_ROOTS) {
-    const rel = [...segs, slug, "slice.contract.ts"].join("/");
-    if (existsSync(path.join(repoRoot, rel))) return rel;
+    if (existsSync(path.join(repoRoot, ...segs, slug, "slice.json"))) {
+      return [...segs, slug, "slice.contract.ts"].join("/");
+    }
   }
   return null;
 }
 
 export function loadCurrentContract(repoRoot, slug) {
-  const p = resolveContractPath(repoRoot, slug);
-  if (!p) return null;
-  return evalContract(repoRoot, p, null);
+  const dir = resolveSliceDir(repoRoot, slug);
+  if (!dir) return null;
+  return loadSliceContract(dir);
 }
 
 /**

package/bin/migrate.mjs

@@ -80,7 +80,7 @@ export async function runMigrate(rest) {
     process.stderr.write(
       kleur.red(
         `migrate: cannot load current contract for "${slug}". ` +
-          `Expected frontend/slices/${slug}/slice.contract.ts or template-base/frontend/slices/${slug}/slice.contract.ts.\n`,
+          `Expected a contract block in frontend/slices/${slug}/slice.json (or template-base/frontend/slices/${slug}/slice.json).\n`,
       ),
     );
     process.exit(1);

package/lib/compose-solver-loader.mjs

@@ -1,13 +1,14 @@
-// compose-solver-loader.mjs — contract discovery + tsx-eval loader.
+// compose-solver-loader.mjs — contract discovery loader.
 //
 // Split out from compose-solver.mjs to keep the pure solver < 200 LOC.
-// I/O entry point only — discovers `slice.contract.ts` under known slice
-// roots and shells out to `npx tsx` to JSON-serialize each export.
+// I/O entry point only — discovers slices under known roots and reads each
+// folded contract from slice.json (`contract` block) via the shared adapter.
+// No tsx subprocess: the contract lives in slice.json since the Phase-2 fold.
 
 import { readdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { spawnSync } from "node:child_process";
 import path from "node:path";
+import { loadSliceContract } from "./load-contract.mjs";
 
 const SLICE_ROOT_GLOBS = [
   ["frontend", "slices"],
@@ -15,11 +16,10 @@ const SLICE_ROOT_GLOBS = [
 ];
 
 /**
- * Discover every `slice.contract.ts` under the kitab's known slice roots and
- * load them via `npx tsx`. Returns a Map<slug, SliceContract>. Contracts that
- * fail to load are silently skipped so a single broken file doesn't take
- * down the whole solver — `npm run validate:contracts` is the place to surface
- * those errors.
+ * Discover every slice with a folded contract under the kitab's known slice
+ * roots. Returns a Map<slug, SliceContract>. Slices without a slice.json
+ * contract block are silently skipped so a single uncontracted slice doesn't
+ * take down the solver — `npm run audit:slices` surfaces shape errors.
  *
  * @param {string} repoRoot Absolute path to the kitab repo root.
  * @returns {Promise<Map<string, import("./contract").SliceContract>>}
@@ -27,9 +27,8 @@ const SLICE_ROOT_GLOBS = [
 export async function loadAllContracts(repoRoot) {
   /** @type {Map<string, import("./contract").SliceContract>} */
   const out = new Map();
-  const sliceFiles = await discoverContractFiles(repoRoot);
-  for (const filePath of sliceFiles) {
-    const contract = loadContractFile(repoRoot, filePath);
+  for (const dir of await discoverSliceDirs(repoRoot)) {
+    const contract = loadSliceContract(dir);
     if (contract && typeof contract.id === "string") {
       out.set(contract.id, contract);
     }
@@ -37,7 +36,7 @@ export async function loadAllContracts(repoRoot) {
   return out;
 }
 
-async function discoverContractFiles(repoRoot) {
+async function discoverSliceDirs(repoRoot) {
   const found = [];
   for (const segs of SLICE_ROOT_GLOBS) {
     const root = path.join(repoRoot, ...segs);
@@ -46,34 +45,9 @@ async function discoverContractFiles(repoRoot) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith("_")) continue;
-      const filePath = path.join(root, entry.name, "slice.contract.ts");
-      if (existsSync(filePath)) found.push(filePath);
+      const dir = path.join(root, entry.name);
+      if (existsSync(path.join(dir, "slice.json"))) found.push(dir);
     }
   }
   return found;
 }
-
-/**
- * Dynamic-import a .ts contract file via `npx tsx -e` and JSON.parse the
- * stringified `contract` export. Returns null on any failure.
- */
-function loadContractFile(repoRoot, filePath) {
-  const rel = "./" + path.relative(repoRoot, filePath);
-  const code = [
-    `import(${JSON.stringify(rel)})`,
-    `  .then(m => { const c = m.contract || (m.default && m.default.contract); if (!c) { process.exit(2); } process.stdout.write(JSON.stringify(c)); })`,
-    `  .catch(() => process.exit(3));`,
-  ].join("\n");
-  const res = spawnSync("npx", ["--no-install", "tsx", "-e", code], {
-    cwd: repoRoot,
-    encoding: "utf8",
-  });
-  if (res.status === 0 && res.stdout) {
-    try {
-      return JSON.parse(res.stdout);
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}

package/lib/compose-solver-resolve.mjs

@@ -32,7 +32,7 @@ export function buildInitialCandidates({
           {
             type: "uncontracted",
             slug,
-            detail: `Slice "${slug}" has no registered slice.contract.ts — accepted under allowUnknownSlices, but conflict checks are skipped for it.`,
+            detail: `Slice "${slug}" has no registered contract — accepted under allowUnknownSlices, but conflict checks are skipped for it.`,
             severity: "warning",
           },
           slug,
@@ -41,13 +41,13 @@ export function buildInitialCandidates({
         candidateSet.add(slug);
         candidateOrder.push(slug);
         notes.set(slug, "uncontracted");
-        proof.push(`! ${slug}: accepted as uncontracted (no slice.contract.ts; skipping conflict checks)`);
+        proof.push(`! ${slug}: accepted as uncontracted (no contract (slice.json); skipping conflict checks)`);
       } else {
         record(
           {
             type: "missing-dep",
             slug,
-            detail: `Contract not found for "${slug}" — no slice.contract.ts registered (strict mode).`,
+            detail: `Contract not found for "${slug}" — no registered contract (strict mode).`,
             severity: "blocker",
           },
           slug,

package/lib/load-contract.mjs

@@ -0,0 +1,33 @@
+// load-contract.mjs — read a slice's folded composition contract from its
+// slice.json (Phase 2 SSOT). Replaces parsing slice.contract.ts: the contract
+// payload now lives under slice.json `contract`, with id/version omitted there
+// (they are the slice.json scalars). This adapter reattaches them so callers
+// get the same SliceContract shape the .ts used to export.
+//
+// Returns undefined when the slice has no slice.json or no contract block —
+// callers treat that exactly like a missing slice.contract.ts before.
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+/**
+ * @param {string} sliceDir Absolute path to frontend/slices/<slug>/.
+ * @returns {object|undefined} { id, version, requires?, provides?, conflicts?,
+ *   migrationFrom?, generalization? } or undefined.
+ */
+export function loadSliceContract(sliceDir) {
+  return contractFromJson(path.join(sliceDir, "slice.json"));
+}
+
+/** Same, given a direct path to a slice.json file. */
+export function contractFromJson(jsonPath) {
+  if (!existsSync(jsonPath)) return undefined;
+  let j;
+  try {
+    j = JSON.parse(readFileSync(jsonPath, "utf8"));
+  } catch {
+    return undefined;
+  }
+  if (!j.contract || typeof j.contract !== "object") return undefined;
+  return { id: j.slug, version: j.version, ...j.contract };
+}

package/lib/slice-schema.json

@@ -315,6 +315,10 @@
     "deprecated": {
       "type": "string",
       "description": "Successor slug. This slice was merged into the named slice as variants; install resolves there via manifest.aliases."
+    },
+    "contract": {
+      "type": "object",
+      "description": "Folded Phase-A composition contract (Phase 2 hybrid fold, 2026-06-21): requires/provides/conflicts/migrationFrom/generalization moved from slice.contract.ts. id+version omitted (== slug/version). requires.deps is verbatim pending per-slice normalization, so this is intentionally loose; strict invariants move to validate-slice when the .ts is retired."
     }
   }
 }

package/lib/snapshot.mjs

@@ -1,13 +1,12 @@
 // snapshot.mjs — build a SliceSnapshot from a slice directory.
 //
 // Walks the directory recursively, keeps only typical slice file extensions,
-// reads `slice.contract.ts` when present and parses it (via `tsx` if
-// available, regex fallback otherwise). Skips node_modules, .kitab, and
-// dotfiles to keep snapshots stable across machines.
+// and reads the folded composition contract from slice.json (`contract` block,
+// id/version reattached from the slice.json scalars). Skips node_modules,
+// .kitab, and dotfiles to keep snapshots stable across machines.
 
 import { readdir, readFile, stat } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { spawnSync } from "node:child_process";
 import path from "node:path";
 
 const INCLUDED_EXT = new Set([".ts", ".tsx", ".mjs", ".js", ".jsx", ".json", ".md", ".css"]);
@@ -33,18 +32,18 @@ export async function snapshotFromDir(slug, dir) {
   const files = {};
   await walk(dir, dir, files);
 
+  // The composition contract is folded into slice.json (`contract` block) since
+  // Phase 2; reattach id/version from the slice.json scalars to keep the same
+  // SliceContract shape the old slice.contract.ts exported.
   let contract;
-  const contractPath = path.join(dir, "slice.contract.ts");
-  if (existsSync(contractPath)) {
-    contract = loadContract(contractPath) ?? regexLoadContract(await readFile(contractPath, "utf8"));
-  }
-
-  // Version preference: contract.version → slice.json.version → "0.0.0".
-  let version = contract?.version ?? "0.0.0";
-  if (!contract?.version && files["slice.json"]) {
+  let version = "0.0.0";
+  if (files["slice.json"]) {
     try {
       const meta = JSON.parse(files["slice.json"]);
       if (typeof meta.version === "string") version = meta.version;
+      if (meta.contract && typeof meta.contract === "object") {
+        contract = { id: meta.slug, version: meta.version, ...meta.contract };
+      }
     } catch {
       /* ignore */
     }
@@ -79,48 +78,3 @@ async function walk(root, dir, out) {
     out[rel] = await readFile(full, "utf8");
   }
 }
-
-/**
- * Mirror of validate-contract.mjs's tsx loader. Returns the parsed contract
- * or undefined on failure.
- */
-function loadContract(filePath) {
-  const code = [
-    `import(${JSON.stringify(filePath)})`,
-    `  .then(m => { const c = m.contract || (m.default && m.default.contract); if (!c) { process.exit(2); } process.stdout.write(JSON.stringify(c)); })`,
-    `  .catch(e => { process.stderr.write(String(e && e.message || e)); process.exit(3); });`,
-  ].join("\n");
-  try {
-    const res = spawnSync("npx", ["--no-install", "tsx", "-e", code], {
-      encoding: "utf8",
-    });
-    if (res.status === 0 && res.stdout) {
-      return JSON.parse(res.stdout);
-    }
-  } catch {
-    /* tsx missing or failed */
-  }
-  return undefined;
-}
-
-/**
- * Best-effort regex fallback: extract the literal-ish object passed to
- * `defineSliceContract({ ... })`. We can't fully parse TS, but for the kitab's
- * contracts (small static literals) a JSON5-ish coerce works for the basic
- * shape we need here.
- */
-function regexLoadContract(src) {
-  const m = src.match(/defineSliceContract\s*\(\s*(\{[\s\S]*?\})\s*\)\s*;?\s*$/m);
-  if (!m) return undefined;
-  // Replace single quotes, strip trailing commas, quote keys.
-  const body = m[1]
-    .replace(/'([^'\\]*)'/g, '"$1"')
-    .replace(/,(\s*[}\]])/g, "$1")
-    .replace(/([{,]\s*)([A-Za-z_$][A-Za-z0-9_$]*)\s*:/g, '$1"$2":')
-    .replace(/\/\/.*$/gm, "");
-  try {
-    return JSON.parse(body);
-  } catch {
-    return undefined;
-  }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rahman-resources",
-  "version": "1.13.3",
+  "version": "1.14.1",
   "description": "Rahman Resources (rr) — shadcn-style installer for vertical slices. `npx resources add <slug>` copies slice into your project's `slices/<slug>/`. You own the files.",
   "type": "module",
   "license": "MIT",
@@ -29,12 +29,12 @@
     "gen": "node scripts/gen-manifest.mjs",
     "validate": "node scripts/validate.mjs",
     "validate:slices": "node scripts/validate-slice.mjs",
-    "validate:parity": "node scripts/validate-slice-parity.mjs",
+    "validate:parity": "node ../../scripts/features/gen-slice-catalog.mjs --check",
     "validate:structure": "node scripts/validate-structure.mjs",
-    "validate:all": "node scripts/validate.mjs && node scripts/validate-slice.mjs --check && node scripts/validate-slice-parity.mjs && node scripts/validate-structure.mjs",
+    "validate:all": "node scripts/validate.mjs && node scripts/validate-slice.mjs --check && node ../../scripts/features/gen-slice-catalog.mjs --check && node scripts/validate-structure.mjs",
     "sync:skills": "node scripts/sync-skills.mjs",
     "sync:skills:check": "node scripts/sync-skills.mjs --check",
-    "prepublishOnly": "node scripts/sync-skills.mjs --check && node scripts/validate.mjs && node scripts/validate-slice.mjs --check && node scripts/validate-slice-parity.mjs && node scripts/validate-structure.mjs"
+    "prepublishOnly": "node scripts/sync-skills.mjs --check && node scripts/validate.mjs && node scripts/validate-slice.mjs --check && node ../../scripts/features/gen-slice-catalog.mjs --check && node scripts/validate-structure.mjs"
   },
   "dependencies": {
     "kleur": "^4.1.5",