@deftai/directive 0.126.0-beta.1 → 0.126.0

package/dist/wip-cap-fixtures.js

@@ -0,0 +1,122 @@
+/** Test fixtures extracted from legacy parity harness (#2083). */
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** Strip volatile absolute paths before compare. */
+export function normalizeOutput(text) {
+    return text.replace(/project_root=[^\s)]+/g, "project_root=<ROOT>");
+}
+function writeProjectDefinition(root, plan) {
+    const dir = join(root, "xbrief");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "PROJECT-DEFINITION.xbrief.json"), `${JSON.stringify({
+        xBRIEFInfo: { version: "0.8" },
+        plan: { title: "T", status: "running", items: [], ...plan },
+    }, null, 2)}\n`, { encoding: "utf8" });
+}
+function writeXbrief(root, folder, name) {
+    const dir = join(root, "xbrief", folder);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, name), `${JSON.stringify({ xBRIEFInfo: { version: "0.8" }, plan: { status: "approved", title: "T", items: [] } })}\n`, { encoding: "utf8" });
+}
+/** Build a throwaway project root with optional PROJECT-DEFINITION and WIP files. */
+export function buildFixtureRepo(options = {}) {
+    const root = mkdtempSync(join(tmpdir(), "deft-wip-cap-parity-"));
+    mkdirSync(join(root, "xbrief"), { recursive: true });
+    if (options.plan !== undefined) {
+        writeProjectDefinition(root, options.plan);
+    }
+    for (let i = 0; i < (options.pendingFiles ?? 0); i += 1) {
+        writeXbrief(root, "pending", `pending-${i}.xbrief.json`);
+    }
+    for (let i = 0; i < (options.activeFiles ?? 0); i += 1) {
+        writeXbrief(root, "active", `active-${i}.xbrief.json`);
+    }
+    return root;
+}
+/** Diff one parity case between Python oracle and TS CLI. */
+export function diffCase(python, ts, caseName) {
+    const pyOut = normalizeOutput(python.stdout);
+    const tsOut = normalizeOutput(ts.stdout);
+    const pyErr = normalizeOutput(python.stderr);
+    const tsErr = normalizeOutput(ts.stderr);
+    return {
+        caseName,
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: pyOut !== tsOut,
+        stderrMismatch: pyErr !== tsErr,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+    };
+}
+export const PARITY_CASES = [
+    {
+        name: "within-cap-typed-empty",
+        argv: [],
+        fixture: { plan: { policy: { wipCap: 5 } } },
+    },
+    {
+        name: "within-cap-with-files",
+        argv: [],
+        fixture: {
+            plan: { policy: { wipCap: 5 } },
+            pendingFiles: 2,
+            activeFiles: 1,
+        },
+    },
+    {
+        name: "over-cap-refusal",
+        argv: [],
+        fixture: {
+            plan: { policy: { wipCap: 2 } },
+            pendingFiles: 1,
+            activeFiles: 1,
+        },
+    },
+    {
+        name: "over-cap-allow-flag",
+        argv: ["--allow-over-cap"],
+        fixture: {
+            plan: { policy: { wipCap: 2 } },
+            pendingFiles: 2,
+        },
+    },
+    {
+        name: "malformed-wipCap",
+        argv: [],
+        fixture: { plan: { policy: { wipCap: -1 } } },
+    },
+    {
+        name: "within-cap-quiet",
+        argv: ["--quiet"],
+        fixture: { plan: { policy: { wipCap: 3 } }, pendingFiles: 1 },
+    },
+    {
+        name: "over-cap-allow-quiet",
+        argv: ["--allow-over-cap", "--quiet"],
+        fixture: {
+            plan: { policy: { wipCap: 1 } },
+            pendingFiles: 2,
+        },
+    },
+];
+/** Run all parity cases; returns aggregate result. */
+export function renderReport(result) {
+    if (result.ok) {
+        return `verify:wip-cap parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} cases.`;
+    }
+    const lines = ["verify:wip-cap parity: DIVERGENCE"];
+    for (const d of result.diffs) {
+        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch) {
+            lines.push(`  case: ${d.caseName}`);
+            if (d.exitMismatch)
+                lines.push(`    exit: python=${d.pythonExit} ts=${d.tsExit}`);
+            if (d.stdoutMismatch)
+                lines.push("    stdout mismatch");
+            if (d.stderrMismatch)
+                lines.push("    stderr mismatch");
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=wip-cap-fixtures.js.map

package/dist/wsl-ownership-guard.d.ts

@@ -0,0 +1,2 @@
+export declare function refuseIfWslOwnershipBlocked(projectRoot: string, writeErr?: (text: string) => void): number | null;
+//# sourceMappingURL=wsl-ownership-guard.d.ts.map

package/dist/wsl-ownership-guard.js

@@ -0,0 +1,15 @@
+/**
+ * Shared live WSL ownership gate for protected mutating CLI entry points (#1617).
+ * Independent of ritual/doctor cache. ownership:doctor/fix are not gated here.
+ */
+import { assertProtectedMutationOwnership } from "@deftai/directive-core/platform";
+export function refuseIfWslOwnershipBlocked(projectRoot, writeErr = (text) => {
+    process.stderr.write(text);
+}) {
+    const gate = assertProtectedMutationOwnership({ projectRoot });
+    if (gate.ok)
+        return null;
+    writeErr(`${gate.message}\n`);
+    return gate.exitCode;
+}
+//# sourceMappingURL=wsl-ownership-guard.js.map

package/dist/xbrief-create.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=xbrief-create.d.ts.map

package/dist/xbrief-create.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runXbriefCreateCli } from "@deftai/directive-core/xbrief";
+const result = runXbriefCreateCli(process.argv.slice(2));
+if (result.stdout)
+    process.stdout.write(result.stdout);
+if (result.stderr)
+    process.stderr.write(result.stderr);
+process.exit(result.exitCode);
+//# sourceMappingURL=xbrief-create.js.map

package/dist/xbrief-verify.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=xbrief-verify.d.ts.map

package/dist/xbrief-verify.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runXbriefVerifyCli } from "@deftai/directive-core/xbrief";
+const result = runXbriefVerifyCli(process.argv.slice(2));
+if (result.stdout)
+    process.stdout.write(result.stdout);
+if (result.stderr)
+    process.stderr.write(result.stderr);
+process.exit(result.exitCode);
+//# sourceMappingURL=xbrief-verify.js.map

package/package.json

@@ -1,20 +1,29 @@
 {
   "name": "@deftai/directive",
-  "version": "0.126.0-beta.1",
-  "description": "Directive launcher — finds the project pin and hands off to @deftai/directive-runtime.",
+  "version": "0.126.0",
+  "description": "Directive CLI — npm install path for the Deft Directive framework.",
   "license": "MIT",
   "homepage": "https://deftai.github.io/directive/",
   "type": "module",
-  "main": "./dist/bin.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "bin": {
     "directive": "./dist/bin.js",
     "deft": "./dist/bin.js",
-    "deft-hook": "./dist/bin.js"
+    "deft-ts": "./dist/bin.js",
+    "deft-hook": "./dist/hook-bin.js",
+    "deft-verify-encoding": "./dist/verify-encoding.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
-    "dist/bin.js",
-    "bin/deft-hook",
-    "bin/deft-hook.cmd"
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "scripts/remove-windows-ps1-shims.mjs"
   ],
   "repository": {
     "type": "git",
@@ -22,13 +31,15 @@
     "directory": "packages/cli"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
-  "engines": {
-    "node": ">=20"
+  "dependencies": {
+    "@deftai/directive-core": "^0.126.0",
+    "@deftai/directive-content": "^0.126.0"
   },
-  "dependencies": {},
   "scripts": {
-    "build": "tsc -b && node ./scripts/bundle.mjs"
+    "build": "tsc -b",
+    "postinstall": "node ./scripts/remove-windows-ps1-shims.mjs"
   }
 }

package/scripts/remove-windows-ps1-shims.mjs

@@ -0,0 +1,26 @@
+/**
+ * postinstall entry (#4654). The published tarball includes dist/.
+ * A workspace install before tsc has no linked shims yet, so a missing
+ * dist file is a no-op rather than a failed install.
+ */
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+const entry = join(pkgDir, "dist", "windows-bin-ps1.js");
+
+if (existsSync(entry)) {
+  const mod = await import(pathToFileURL(entry).href);
+  const result = mod.removeInstalledWindowsPs1Shims({
+    pkgDir,
+    env: process.env,
+    platform: process.platform,
+  });
+  if (result.failed.length > 0) {
+    process.stderr.write(
+      `remove-windows-ps1-shims: could not remove ${result.failed.join(", ")}\n`,
+    );
+    process.exitCode = 1;
+  }
+}

package/bin/deft-hook

@@ -1,14 +0,0 @@
-#!/bin/sh
-# PATH shim for deft-hook (AC3.5). Sets DEFT_LAUNCHER_MODE and runs the single
-# dist/bin.js (D4.3). Resolve symlinks so npm's .bin/deft-hook link finds dist/.
-SOURCE=$0
-while [ -L "$SOURCE" ]; do
-  TARGET=$(readlink "$SOURCE")
-  case "$TARGET" in
-    /*) SOURCE=$TARGET ;;
-    *) SOURCE=$(dirname "$SOURCE")/$TARGET ;;
-  esac
-done
-DIR=$(CDPATH= cd -- "$(dirname "$SOURCE")" && pwd)
-export DEFT_LAUNCHER_MODE=hook
-exec node "$DIR/../dist/bin.js" "$@"

package/bin/deft-hook.cmd

@@ -1,14 +0,0 @@
-@ECHO OFF
-REM Windows PATH shim for deft-hook (AC3.5). npm may not auto-pick this file when
-REM bin points at the POSIX script; keep beside bin/deft-hook for manual/global use
-REM and for package managers that install sibling .cmd. Sets mode and runs bin.js.
-SET DEFT_LAUNCHER_MODE=hook
-NODE_EXE=node
-WHERE node >NUL 2>&1 || SET NODE_EXE=node.exe
-"%~dp0..\dist\bin.js" 2>NUL
-IF EXIST "%~dp0..\dist\bin.js" (
-  %NODE_EXE% "%~dp0..\dist\bin.js" %*
-  EXIT /B %ERRORLEVEL%
-)
-ECHO deft-hook: missing %~dp0..\dist\bin.js
-EXIT /B 1