@deftai/directive 0.126.0-beta.2 → 0.126.0

package/dist/cli-router/route-argv.js

@@ -0,0 +1,371 @@
+/**
+ * Maps `directive <namespace> <verb>` argv to flat dispatcher verbs (#1670 / #11 S3).
+ * Mirrors the `task <namespace>:<verb>` surface one-to-one.
+ */
+import { resolveCanonicalVerb } from "../dispatch.js";
+/** Top-level UX verbs promoted above the namespace layer (#1670). */
+export const TOP_LEVEL_UX_VERBS = [
+    "init",
+    "update",
+    "migrate",
+    "bootstrap",
+    "check",
+    "doctor",
+    "version",
+    "feature",
+];
+/** Stubbed until a later story lands the handler (#1670 / #11). */
+export const STUBBED_TOP_LEVEL_VERBS = new Set([]);
+/** Registered but not yet implemented as TS handlers. */
+export const DEFERRED_TOP_LEVEL_VERBS = new Set(["feature"]);
+/** scope:* lifecycle verbs routed through scope-lifecycle handler. */
+export const SCOPE_LIFECYCLE_VERBS = new Set([
+    "promote",
+    "activate",
+    "complete",
+    "fail",
+    "cancel",
+    "restore",
+    "block",
+    "unblock",
+    "stamp-evidence",
+    "bind-clause",
+]);
+/** pr:* task names that do not hyphenate 1:1 to handler stems. */
+export const PR_VERB_MAP = {
+    "merge-ready": "pr-merge-readiness",
+    "check-protected-issues": "pr-protected-issues",
+    "check-closing-keywords": "pr-closing-keywords",
+    "wait-mergeable-and-merge": "pr-wait-mergeable",
+    watch: "pr-watch",
+    "finish-loop": "pr-finish-loop",
+};
+/** verify:* aliases that map to non-verify-* handler stems. */
+export const VERIFY_VERB_MAP = {
+    routing: "swarm-routing-verify",
+    "codebase-map-fresh": "codebase-map-fresh",
+    "strategy-output": "validate-strategy-output",
+    "vbrief-conformance": "vbrief-validate",
+    "destructive-gh-verbs": "preflight-gh",
+    "cache-fresh": "preflight-cache",
+    "pack-drift": "pack-render",
+};
+/** Namespace handlers that require a subcommand token after the handler stem. */
+export const SUBCOMMAND_ROUTES = {
+    "triage:accept": ["triage-actions", "accept"],
+    "triage:reject": ["triage-actions", "reject"],
+    "triage:defer": ["triage-actions", "defer"],
+    "triage:needs-ac": ["triage-actions", "needs-ac"],
+    "triage:mark-duplicate": ["triage-actions", "mark-duplicate"],
+    "triage:status": ["triage-actions", "status"],
+    "triage:reset": ["triage-actions", "reset"],
+    "triage:history": ["triage-actions", "history"],
+    "triage:bulk-accept": ["triage-bulk", "accept"],
+    "triage:bulk-reject": ["triage-bulk", "reject"],
+    "triage:bulk-defer": ["triage-bulk", "defer"],
+    "triage:bulk-needs-ac": ["triage-bulk", "needs-ac"],
+    "triage:show": ["triage-queue", "show"],
+    "triage:audit": ["triage-queue", "audit"],
+    "cache:put": ["cache", "put"],
+    "cache:get": ["cache", "get"],
+    "cache:invalidate": ["cache", "invalidate"],
+    "cache:fetch-all": ["cache", "fetch-all"],
+    "cache:prune": ["cache", "prune"],
+    "cache:clear": ["cache", "clear"],
+    "cache:archive-closed": ["cache", "archive-closed"],
+    "cache:archive-list": ["cache", "archive-list"],
+    "cache:restore-from-archive": ["cache", "restore-from-archive"],
+    "triage:cache-archive": ["cache", "archive-closed"],
+    "triage:archive-list": ["cache", "archive-list"],
+    "triage:restore-from-archive": ["cache", "restore-from-archive"],
+    "policy:show": ["policy", "show"],
+    "policy:disable-directive": ["policy", "disable-directive"],
+    "policy:enable-directive": ["policy", "enable-directive"],
+    "policy:enforce-branches": ["policy", "enforce-branches"],
+    "policy:allow-direct-commits": ["policy", "allow-direct-commits"],
+    "policy:allow-destructive-gh-verbs": ["policy", "allow-destructive-gh-verbs"],
+    "policy:enforce-destructive-gh-verbs": ["policy", "enforce-destructive-gh-verbs"],
+    "policy:allow-bot-merge": ["policy", "allow-bot-merge"],
+    "policy:enable-value-feedback": ["policy", "enable-value-feedback"],
+    "policy:disable-host-hooks": ["policy", "disable-host-hooks"],
+    "policy:set-ceremony-dial": ["policy", "set-ceremony-dial"],
+    "policy:set-spec-guard-enforcement": ["policy", "set-spec-guard-enforcement"],
+    "policy:clear-value-feedback": ["policy", "clear-value-feedback"],
+    "authz:show": ["authz", "show"],
+    "authz:uat-start": ["authz", "uat-start"],
+    "authz:uat-suspend": ["authz", "uat-suspend"],
+    "authz:grant": ["authz", "grant"],
+    "authz:revoke": ["authz", "revoke"],
+    "escalation:file": ["escalation-cli", "file"],
+    "escalation:list": ["escalation-cli", "list"],
+    "escalation:resolve": ["escalation-cli", "resolve"],
+    "escalation:batch-approve": ["escalation-cli", "batch-approve"],
+    "product-signal:status": ["product-signal", "status"],
+    "product-signal:enable": ["product-signal", "enable"],
+    "product-signal:consent": ["product-signal", "consent"],
+    "product-signal:submit": ["product-signal", "submit"],
+    "product-signal:bootstrap-sink": ["product-signal", "bootstrap-sink"],
+    "vbrief:reconcile-graph": ["vbrief-reconcile", "graph"],
+    "vbrief:reconcile-labels": ["vbrief-reconcile", "labels"],
+    "vbrief:reconcile-umbrellas": ["vbrief-reconcile", "umbrellas"],
+    "slice:record-existing": ["slice", "record-existing"],
+    "slice:list": ["slice", "list"],
+    "github-body:issue-create": ["github-body", "issue-create"],
+    "github-body:issue-edit": ["github-body", "issue-edit"],
+    "github-body:issue-fetch": ["github-body", "issue-fetch"],
+    "github-body:issue-lint": ["github-body", "issue-lint"],
+    "github-body:comment-create": ["github-body", "comment-create"],
+    "github-body:comment-edit": ["github-body", "comment-edit"],
+    "github-body:pr-edit": ["github-body", "pr-edit"],
+    "github-body:pr-lint": ["github-body", "pr-lint"],
+    // #5521: pinned AGENTS scm:body:* colon aliases → github-body engine (argv inserts subcommand)
+    "scm:body:issue:create": ["github-body", "issue-create"],
+    "scm:body:issue:edit": ["github-body", "issue-edit"],
+    "scm:body:issue:fetch": ["github-body", "issue-fetch"],
+    "scm:body:issue:lint": ["github-body", "issue-lint"],
+    "scm:body:comment:create": ["github-body", "comment-create"],
+    "scm:body:comment:edit": ["github-body", "comment-edit"],
+    "scm:body:pr:edit": ["github-body", "pr-edit"],
+    "scm:body:pr:lint": ["github-body", "pr-lint"],
+    "plan-sequence:set": ["plan-sequence", "set"],
+    "plan-sequence:current": ["plan-sequence", "current"],
+    "plan-sequence:clear": ["plan-sequence", "clear"],
+    "plan-sequence:advance": ["plan-sequence", "advance"],
+};
+/** Eight scm:body:* dual-invoke names (#5521); keep in sync with SUBCOMMAND_ROUTES above. */
+export const SCM_BODY_COLON_VERBS = [
+    "scm:body:issue:create",
+    "scm:body:issue:edit",
+    "scm:body:issue:fetch",
+    "scm:body:issue:lint",
+    "scm:body:comment:create",
+    "scm:body:comment:edit",
+    "scm:body:pr:edit",
+    "scm:body:pr:lint",
+];
+/**
+ * Colon forms handled by explicit `routeNamespaceVerb` branches (not SUBCOMMAND_ROUTES /
+ * PR_VERB_MAP / VERIFY_VERB_MAP / SCOPE_LIFECYCLE_VERBS). Scraped by rule-to-verb parity
+ * so valid citations like `deft framework:doctor` pass (#5521).
+ */
+export const ROUTER_BRANCH_COLON_VERBS = [
+    "framework:doctor",
+    "agents:refresh",
+    "scope:demote",
+    "scope:decompose",
+    "scope:undo",
+    "scope:record-approved-scope",
+    "scope:record-observable-scope",
+    "scope:record-intent-constraint",
+    "scm:issue:design-critique-chip",
+    "scm:issue:design-critique-stale-ready",
+    "scm:issue:work-claim",
+    "issue:ingest",
+    "issue:emit",
+    "issue:sync-from-xbrief",
+];
+function isMetaVerb(token) {
+    return token === "--help" || token === "-h" || token === "--version" || token === "-V";
+}
+function routeTopLevel(first, rest) {
+    if (first === "version") {
+        return { kind: "dispatch", argv: ["--version", ...rest] };
+    }
+    if (first === "check" || first === "doctor") {
+        return { kind: "dispatch", argv: [first, ...rest] };
+    }
+    if (first === "init" || first === "update" || first === "migrate" || first === "bootstrap") {
+        return { kind: "dispatch", argv: [first, ...rest] };
+    }
+    if (STUBBED_TOP_LEVEL_VERBS.has(first)) {
+        return {
+            kind: "stub",
+            argv: [],
+            stubMessage: `directive ${first}: not yet implemented in the TS CLI (#1670 / #11).`,
+        };
+    }
+    if (DEFERRED_TOP_LEVEL_VERBS.has(first)) {
+        return {
+            kind: "stub",
+            argv: [],
+            stubMessage: `directive ${first}: not yet implemented in the TS CLI (#1670 / #11).`,
+        };
+    }
+    return null;
+}
+function routeSubcommandKey(ns, verb, rest) {
+    const colonKey = `${ns}:${verb}`;
+    const mapped = SUBCOMMAND_ROUTES[colonKey];
+    if (mapped !== undefined) {
+        return { kind: "dispatch", argv: [...mapped, ...rest] };
+    }
+    return null;
+}
+function routeNamespaceVerb(ns, verb, rest) {
+    const colonKey = `${ns}:${verb}`;
+    const subcommand = routeSubcommandKey(ns, verb, rest);
+    if (subcommand !== null)
+        return subcommand;
+    // PR stems (watch → pr-watch) must win over colon aliases like pr:watch (#2652),
+    // otherwise `directive pr watch` would dispatch the colon token and break PR_VERB_MAP.
+    if (ns === "pr") {
+        const prStem = PR_VERB_MAP[verb];
+        if (prStem !== undefined) {
+            return { kind: "dispatch", argv: [prStem, ...rest] };
+        }
+    }
+    if (resolveCanonicalVerb(colonKey) !== null) {
+        return { kind: "dispatch", argv: [colonKey, ...rest] };
+    }
+    if (ns === "framework" && verb === "doctor") {
+        return { kind: "dispatch", argv: ["doctor", ...rest] };
+    }
+    if (ns === "agents" && verb === "refresh") {
+        return { kind: "dispatch", argv: ["agents-refresh", ...rest] };
+    }
+    if (ns === "scope") {
+        if (SCOPE_LIFECYCLE_VERBS.has(verb)) {
+            return { kind: "dispatch", argv: ["scope-lifecycle", verb, ...rest] };
+        }
+        if (verb === "demote")
+            return { kind: "dispatch", argv: ["scope-demote", ...rest] };
+        if (verb === "decompose")
+            return { kind: "dispatch", argv: ["scope-decompose", ...rest] };
+        if (verb === "undo")
+            return { kind: "dispatch", argv: ["scope-undo", ...rest] };
+        if (verb === "record-approved-scope") {
+            return { kind: "dispatch", argv: ["scope-record-approved-scope", ...rest] };
+        }
+        if (verb === "record-observable-scope") {
+            return { kind: "dispatch", argv: ["scope-record-observable-scope", ...rest] };
+        }
+        if (verb === "record-intent-constraint") {
+            return { kind: "dispatch", argv: ["scope-record-intent-constraint", ...rest] };
+        }
+    }
+    if (ns === "verify") {
+        const verifyStem = VERIFY_VERB_MAP[verb];
+        if (verifyStem !== undefined) {
+            return { kind: "dispatch", argv: [verifyStem, ...rest] };
+        }
+    }
+    if (ns === "scm" && verb === "issue:design-critique-chip") {
+        return { kind: "dispatch", argv: ["scm", "issue", "design-critique-chip", ...rest] };
+    }
+    if (ns === "scm" && verb === "issue:design-critique-stale-ready") {
+        return { kind: "dispatch", argv: ["scm", "issue", "design-critique-stale-ready", ...rest] };
+    }
+    if (ns === "scm" && verb === "issue:work-claim") {
+        return { kind: "dispatch", argv: ["scm", "issue", "work-claim", ...rest] };
+    }
+    if (ns === "issue" && verb === "ingest") {
+        return { kind: "dispatch", argv: ["issue-ingest", ...rest] };
+    }
+    if (ns === "issue" && verb === "emit") {
+        return { kind: "dispatch", argv: ["issue-emit", ...rest] };
+    }
+    if (ns === "issue" && verb === "sync-from-xbrief") {
+        return { kind: "dispatch", argv: ["issue-sync-from-xbrief", ...rest] };
+    }
+    if (ns === "triage" && verb.startsWith("bulk-")) {
+        return { kind: "dispatch", argv: ["triage-bulk", verb.slice("bulk-".length), ...rest] };
+    }
+    const hyphenStem = `${ns}-${verb}`;
+    if (resolveCanonicalVerb(hyphenStem) !== null) {
+        return { kind: "dispatch", argv: [hyphenStem, ...rest] };
+    }
+    return null;
+}
+/** Split `namespace:verb` task keys (e.g. scope:promote) for namespace routing (#2654). */
+function tryColonNamespaceRoute(first, rest) {
+    // Registered colon aliases (policy:show, pr:watch, …) stay on the flat path.
+    if (resolveCanonicalVerb(first) !== null)
+        return null;
+    const colon = first.indexOf(":");
+    if (colon <= 0)
+        return null;
+    const ns = first.slice(0, colon);
+    const verb = first.slice(colon + 1);
+    if (verb.length === 0)
+        return null;
+    return routeNamespaceVerb(ns, verb, [...rest]);
+}
+/** Split `scope-<verb>` dash aliases (e.g. scope-promote) for namespace routing (#2654). */
+function tryScopeDashRoute(first, rest) {
+    if (resolveCanonicalVerb(first) !== null)
+        return null;
+    const prefix = "scope-";
+    if (!first.startsWith(prefix))
+        return null;
+    const verb = first.slice(prefix.length);
+    if (verb.length === 0)
+        return null;
+    return routeNamespaceVerb("scope", verb, [...rest]);
+}
+function routeThreeToken(ns, verb, subverb, rest) {
+    if (ns === "scm" && verb === "issue") {
+        return { kind: "dispatch", argv: ["scm", "issue", subverb, ...rest] };
+    }
+    if (ns === "vbrief" && verb === "reconcile") {
+        return { kind: "dispatch", argv: ["vbrief-reconcile", subverb, ...rest] };
+    }
+    if (ns === "policy" && verb === "set") {
+        return { kind: "dispatch", argv: ["policy-set", subverb, ...rest] };
+    }
+    const compositeKey = `${ns}:${verb}-${subverb}`;
+    const subcommand = SUBCOMMAND_ROUTES[compositeKey];
+    if (subcommand !== undefined) {
+        return { kind: "dispatch", argv: [...subcommand, ...rest] };
+    }
+    return null;
+}
+/**
+ * Transform user-facing argv (`directive <ns> <verb>` or top-level UX) into
+ * flat dispatcher argv consumed by `dispatch()`.
+ */
+export function routeArgv(argv) {
+    if (argv.length === 0) {
+        return { kind: "dispatch", argv: [] };
+    }
+    const [first, second, third, ...tail] = argv;
+    if (first === undefined) {
+        return { kind: "dispatch", argv: [] };
+    }
+    if (isMetaVerb(first) || first === "help") {
+        return { kind: "dispatch", argv: [...argv] };
+    }
+    const topLevel = routeTopLevel(first, argv.slice(1));
+    if (topLevel !== null)
+        return topLevel;
+    const colonRoute = tryColonNamespaceRoute(first, argv.slice(1));
+    if (colonRoute !== null)
+        return colonRoute;
+    const scopeDashRoute = tryScopeDashRoute(first, argv.slice(1));
+    if (scopeDashRoute !== null)
+        return scopeDashRoute;
+    if (argv.length === 1 && resolveCanonicalVerb(first) !== null) {
+        return { kind: "dispatch", argv: [first] };
+    }
+    if (second !== undefined) {
+        const nsRoute = routeNamespaceVerb(first, second, third !== undefined ? [third, ...tail] : tail);
+        if (nsRoute !== null)
+            return nsRoute;
+    }
+    if (second !== undefined && third !== undefined) {
+        const threeToken = routeThreeToken(first, second, third, tail);
+        if (threeToken !== null)
+            return threeToken;
+    }
+    return { kind: "dispatch", argv: [...argv] };
+}
+/** Map `namespace:verb` task key to flat dispatcher argv (test seam). */
+export function taskKeyToDispatchArgv(taskKey, rest = []) {
+    const colon = taskKey.indexOf(":");
+    if (colon <= 0)
+        return null;
+    const ns = taskKey.slice(0, colon);
+    const verb = taskKey.slice(colon + 1);
+    const routed = routeNamespaceVerb(ns, verb, [...rest]);
+    return routed?.kind === "dispatch" ? routed.argv : null;
+}
+//# sourceMappingURL=route-argv.js.map

package/dist/codebase-default-extractor.d.ts

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

package/dist/codebase-default-extractor.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runDefaultExtractorCli } from "@deftai/directive-core/codebase";
+const result = runDefaultExtractorCli(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=codebase-default-extractor.js.map

package/dist/codebase-map-fresh.d.ts

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

package/dist/codebase-map-fresh.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCodebaseMapFreshCli } from "@deftai/directive-core/codebase";
+const result = runCodebaseMapFreshCli(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=codebase-map-fresh.js.map

package/dist/codebase-map.d.ts

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

package/dist/codebase-map.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCodebaseMapCli } from "@deftai/directive-core/codebase";
+const result = runCodebaseMapCli(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=codebase-map.js.map

package/dist/codebase-projection-registry.d.ts

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

package/dist/codebase-projection-registry.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runProjectionRegistryCli } from "@deftai/directive-core/codebase";
+const result = runProjectionRegistryCli(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=codebase-projection-registry.js.map

package/dist/codebase-provider.d.ts

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

package/dist/codebase-provider.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runProviderCli } from "@deftai/directive-core/codebase";
+const result = runProviderCli(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=codebase-provider.js.map

package/dist/commit-lint.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=commit-lint.d.ts.map

package/dist/commit-lint.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runCommitLint } from "@deftai/directive-core/task-surface";
+function parseProjectRoot(argv) {
+    let projectRoot = ".";
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? "";
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { projectRoot, error: "argument --project-root: expected one argument" };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { projectRoot, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { projectRoot };
+}
+export function run(argv) {
+    const args = parseProjectRoot(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`commit-lint: ${args.error}\n`);
+        return 2;
+    }
+    return runCommitLint(resolve(args.projectRoot), {
+        writeOut: (text) => {
+            process.stdout.write(text);
+        },
+        writeErr: (text) => {
+            process.stderr.write(text);
+        },
+    });
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=commit-lint.js.map

package/dist/content-validate-cli/validate-links.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    strict: boolean;
+    error?: string;
+}
+/** Parse validate-links CLI args, mirroring scripts/validate-links.py. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=validate-links.d.ts.map

package/dist/content-validate-cli/validate-links.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { validateLinks } from "@deftai/directive-core/validate-content";
+/** Parse validate-links CLI args, mirroring scripts/validate-links.py. */
+export function parseArgs(argv) {
+    const parsed = { strict: false };
+    for (const arg of argv) {
+        if (arg === "--strict") {
+            parsed.strict = true;
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the gate and return the process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`validate-links: ${args.error}\n`);
+        return 2;
+    }
+    const result = validateLinks.evaluate({
+        cwd: resolve("."),
+        strict: args.strict,
+        argv,
+        linkCheckStrict: process.env.LINK_CHECK_STRICT === "1",
+    });
+    process.stdout.write(`${result.message}\n`);
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=validate-links.js.map

package/dist/content-validate-cli/validate-strategy-output.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    strict: boolean;
+    quiet: boolean;
+    error?: string;
+}
+/** Parse validate-strategy-output CLI args, mirroring scripts/validate_strategy_output.py. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=validate-strategy-output.d.ts.map

package/dist/content-validate-cli/validate-strategy-output.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { validateStrategyOutput } from "@deftai/directive-core/validate-content";
+/** Parse validate-strategy-output CLI args, mirroring scripts/validate_strategy_output.py. */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", strict: false, quiet: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--strict") {
+            parsed.strict = true;
+        }
+        else if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the gate and return the process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`validate_strategy_output: ${args.error}\n`);
+        return 2;
+    }
+    const result = validateStrategyOutput.evaluate({
+        projectRoot: resolve(args.projectRoot),
+        strict: args.strict,
+        quiet: args.quiet,
+    });
+    if (result.stream === "stdout" && result.message.length > 0) {
+        process.stdout.write(`${result.message}\n`);
+    }
+    else if (result.stream === "stderr" && result.message.length > 0) {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=validate-strategy-output.js.map

package/dist/content-validate-cli/verify-capacity.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    quiet: boolean;
+    error?: string;
+}
+/** Parse verify-capacity CLI args, mirroring scripts/verify_capacity.py. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-capacity.d.ts.map