@deftai/directive 0.58.0 → 0.60.0

package/dist/change-init.d.ts

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

package/dist/change-init.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runChangeInit } from "@deftai/directive-core/task-surface";
+function parseArgs(argv) {
+    let projectRoot = ".";
+    let name = "";
+    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, name, error: "argument --project-root: expected one argument" };
+            }
+            projectRoot = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--project-root=")) {
+            projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--name") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { projectRoot, name, error: "argument --name: expected one argument" };
+            }
+            name = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--name=")) {
+            name = arg.slice("--name=".length);
+        }
+        else if (!arg.startsWith("-") && name.length === 0) {
+            name = arg;
+        }
+        else {
+            return { projectRoot, name, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return { projectRoot, name };
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`change-init: ${args.error}\n`);
+        return 2;
+    }
+    return runChangeInit(resolve(args.projectRoot), args.name, {
+        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=change-init.js.map

package/dist/changelog-check.d.ts

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

package/dist/changelog-check.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runChangelogCheck } 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(`changelog-check: ${args.error}\n`);
+        return 2;
+    }
+    return runChangelogCheck(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=changelog-check.js.map

package/dist/cli-router/index.js

@@ -1,7 +1,7 @@
 /**
  * CLI router entry: `directive <namespace> <verb>` → flat dispatcher (#1670 / #11 S3).
  */
-import { dispatch } from "../dispatch.js";
+import { dispatch, runDirectiveBootstrap } from "../dispatch.js";
 import { runInit } from "../init-cli/init.js";
 import { runMigrate } from "../init-cli/migrate.js";
 import { runUpdate } from "../init-cli/update.js";
@@ -36,6 +36,9 @@ export async function routeAndDispatch(argv, io) {
     if (first === "migrate") {
         return runMigrate(rest, io ?? defaultIo());
     }
+    if (first === "bootstrap") {
+        return runDirectiveBootstrap(rest, io ?? defaultIo());
+    }
     return dispatch(routed.argv, io);
 }
 //# sourceMappingURL=index.js.map

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

@@ -17,7 +17,7 @@ export const TOP_LEVEL_UX_VERBS = [
 /** 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(["bootstrap", "feature"]);
+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",
@@ -91,7 +91,7 @@ function routeTopLevel(first, rest) {
     if (first === "check" || first === "doctor") {
         return { kind: "dispatch", argv: [first, ...rest] };
     }
-    if (first === "init" || first === "update" || first === "migrate") {
+    if (first === "init" || first === "update" || first === "migrate" || first === "bootstrap") {
         return { kind: "dispatch", argv: [first, ...rest] };
     }
     if (STUBBED_TOP_LEVEL_VERBS.has(first)) {

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/dispatch.d.ts

@@ -2,17 +2,78 @@
  * Unified `directive <verb> [args]` dispatcher (#1828 s0).
  * Routes to ported command modules in packages/cli and packages/core.
  */
+import { spawnSync } from "node:child_process";
+import { type WhichFn } from "@deftai/directive-core/scm";
 export type CommandHandler = (argv: string[]) => number | Promise<number>;
 export interface DispatchIo {
     writeOut: (text: string) => void;
     writeErr: (text: string) => void;
 }
 /** CLI modules in packages/cli/src (excluding parity harnesses and bin/index). */
-export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "parity", "policy", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "verify-branch", "verify-encoding", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-bridge-drift", "verify-capacity", "verify-content-manifest", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-stubs", "rule-ownership-lint", "verify-story-ready", "verify-tools", "verify-wip-cap"];
+export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "install-upgrade", "install-uninstall", "migrate-preflight", "changelog-check", "change-init", "commit-lint", "parity", "policy", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "session-start", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "verify-branch", "verify-encoding", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-bridge-drift", "verify-capacity", "verify-content-manifest", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-stubs", "rule-ownership-lint", "verify-story-ready", "verify-tools", "verify-wip-cap"];
 /** Core-only CLI entrypoints without a packages/cli wrapper. */
-export declare const CORE_MODULE_VERBS: readonly ["scm", "github-auth-modes", "github-body", "issue-emit", "issue-ingest", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "project-render", "roadmap-render", "spec-render", "spec-validate", "code-structure-validate", "pack-migrate-skills", "pack-migrate-rules", "pack-migrate-strategies", "pack-migrate-patterns", "pack-migrate-swarm-spec", "policy-set", "scope-undo", "scope-demote", "scope-decompose", "changelog-resolve-unreleased", "architecture-preflight-sor"];
+export declare const CORE_MODULE_VERBS: readonly ["scm", "github-auth-modes", "github-body", "issue-emit", "issue-ingest", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "project-render", "roadmap-render", "spec-render", "spec-validate", "code-structure-validate", "pack-migrate-skills", "pack-migrate-rules", "pack-migrate-strategies", "pack-migrate-patterns", "pack-migrate-swarm-spec", "policy-set", "setup-ghx", "scope-undo", "scope-demote", "scope-decompose", "changelog-resolve-unreleased", "architecture-preflight-sor"];
 /** Task-style aliases (framework_commands / Taskfile names). */
 export declare const VERB_ALIASES: Readonly<Record<string, string>>;
+/** Pinned ghx version — keep in lockstep with .github/workflows/ci.yml env.GHX_VERSION. */
+export declare const GHX_VERSION = "v1.5.1";
+export declare const INSTALL_PS1_URL = "https://raw.githubusercontent.com/brunoborges/ghx/v1.5.1/install.ps1";
+export declare const INSTALL_SH_URL = "https://raw.githubusercontent.com/brunoborges/ghx/v1.5.1/install.sh";
+export type SetupGhxHost = "windows" | "darwin" | "linux" | string;
+export interface SetupGhxDeps {
+    whichFn?: WhichFn;
+    readConsentLine?: () => string;
+    runInstall?: (host: SetupGhxHost) => number;
+}
+export declare function ghxPresent(whichFn?: WhichFn): boolean;
+export declare function detectSetupGhxHost(): SetupGhxHost;
+export declare function promptSetupGhxConsent(io: DispatchIo, readLine?: () => string): boolean;
+export declare function buildSetupGhxInstallCommand(host: SetupGhxHost, whichFn?: WhichFn): string[];
+export declare function installSetupGhx(host: SetupGhxHost, whichFn?: WhichFn, runner?: typeof spawnSync): number;
+/** Native `setup:ghx` handler (replaces scripts/setup_ghx.py shell-out, #2022 Phase 1). */
+export declare function runSetupGhx(argv: string[], io: DispatchIo, deps?: SetupGhxDeps): number;
+export declare const SETUP_SKILL_REL_PATH = ".deft/core/skills/deft-directive-setup/SKILL.md";
+export type BootstrapPhaseLabel = "user" | "project" | "spec";
+export type BootstrapReEntry = "none" | "prompt" | "reconfigure" | "force";
+export interface DirectiveBootstrapArgs {
+    projectRoot: string;
+    jumpProject: boolean;
+    strategy: string | null;
+    reconfigure: boolean;
+    force: boolean;
+    json: boolean;
+    error?: string;
+}
+export interface DirectiveBootstrapPlan {
+    phase: 1 | 2 | 3;
+    phaseLabel: BootstrapPhaseLabel;
+    reEntry: BootstrapReEntry;
+    strategy: string | null;
+}
+export interface DirectiveBootstrapHandoff {
+    handoff: "deft-directive-setup";
+    skill_path: string;
+    project_root: string;
+    deposited: boolean;
+    phase: 1 | 2 | 3;
+    phase_label: BootstrapPhaseLabel;
+    re_entry: BootstrapReEntry;
+    strategy: string | null;
+}
+export interface DirectiveBootstrapDeps {
+    deftCorePresent?: (projectRoot: string) => boolean;
+    userMdPresent?: (projectRoot: string) => boolean;
+    projectDefPresent?: (projectRoot: string) => boolean;
+    runInitDeposit?: (projectRoot: string, io: DispatchIo) => Promise<number>;
+}
+/** Parse `directive bootstrap` argv (#2022 Phase 4). */
+export declare function parseDirectiveBootstrapArgs(argv: readonly string[]): DirectiveBootstrapArgs;
+/** Resolve phase intent and deliberate re-entry signal from parsed args + on-disk state. */
+export declare function resolveDirectiveBootstrapPlan(args: DirectiveBootstrapArgs, deps: Required<DirectiveBootstrapDeps>): DirectiveBootstrapPlan;
+/** Native `directive bootstrap` handler (#2022 Phase 4). */
+export declare function runDirectiveBootstrap(argv: string[], io: DispatchIo, deps?: DirectiveBootstrapDeps): Promise<number>;
+/** Native `policy-set` dispatcher (replaces the policy_set.py shell-out, #2022 Phase 1). */
+export declare function runPolicySet(argv: string[], io: DispatchIo): number;
 /** Resolve a user-facing verb to its canonical handler key. */
 export declare function resolveCanonicalVerb(verb: string): string | null;
 /** Sorted list of all registered verb names (canonical + aliases). */