@deftai/directive-core 0.55.0

package/dist/slice/cli.js

@@ -0,0 +1,248 @@
+import { fileURLToPath } from "node:url";
+import { consumeWaveFlags, DEFAULT_ACTOR, DEFAULT_EXPECTED_CLOSE_SIGNAL, runList, runRecordExisting, } from "./existing.js";
+function parseFlagValue(argv, index, prefix) {
+    const arg = argv[index];
+    if (arg === prefix) {
+        const value = argv[index + 1];
+        if (value === undefined) {
+            return null;
+        }
+        return { value, next: index + 2 };
+    }
+    if (arg?.startsWith(`${prefix}=`)) {
+        return { value: arg.slice(prefix.length + 1), next: index + 1 };
+    }
+    return undefined;
+}
+function parseRecordExisting(argv) {
+    const parsed = {
+        umbrella: 0,
+        children: "",
+        actor: DEFAULT_ACTOR,
+        expectedCloseSignal: DEFAULT_EXPECTED_CLOSE_SIGNAL,
+        slicedAt: null,
+        notes: null,
+        dryRun: false,
+        force: false,
+        skipValidation: false,
+        repo: null,
+        projectRoot: null,
+    };
+    let hasUmbrella = false;
+    let hasChildren = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--dry-run") {
+            parsed.dryRun = true;
+        }
+        else if (arg === "--force") {
+            parsed.force = true;
+        }
+        else if (arg === "--skip-validation") {
+            parsed.skipValidation = true;
+        }
+        else if (arg === "--json") {
+            return { args: parsed, error: "unrecognized arguments: --json" };
+        }
+        else {
+            const umbrella = parseFlagValue(argv, i, "--umbrella");
+            if (umbrella !== null && umbrella !== undefined) {
+                if (umbrella === null) {
+                    return { args: parsed, error: "argument --umbrella: expected one argument" };
+                }
+                parsed.umbrella = Number.parseInt(umbrella.value, 10);
+                hasUmbrella = true;
+                i = umbrella.next - 1;
+                continue;
+            }
+            const children = parseFlagValue(argv, i, "--children");
+            if (children !== null && children !== undefined) {
+                if (children === null) {
+                    return { args: parsed, error: "argument --children: expected one argument" };
+                }
+                parsed.children = children.value;
+                hasChildren = true;
+                i = children.next - 1;
+                continue;
+            }
+            const actor = parseFlagValue(argv, i, "--actor");
+            if (actor !== null && actor !== undefined) {
+                if (actor === null) {
+                    return { args: parsed, error: "argument --actor: expected one argument" };
+                }
+                parsed.actor = actor.value;
+                i = actor.next - 1;
+                continue;
+            }
+            const signal = parseFlagValue(argv, i, "--expected-close-signal");
+            if (signal !== null && signal !== undefined) {
+                if (signal === null) {
+                    return { args: parsed, error: "argument --expected-close-signal: expected one argument" };
+                }
+                parsed.expectedCloseSignal = signal.value;
+                i = signal.next - 1;
+                continue;
+            }
+            const slicedAt = parseFlagValue(argv, i, "--sliced-at");
+            if (slicedAt !== null && slicedAt !== undefined) {
+                if (slicedAt === null) {
+                    return { args: parsed, error: "argument --sliced-at: expected one argument" };
+                }
+                parsed.slicedAt = slicedAt.value;
+                i = slicedAt.next - 1;
+                continue;
+            }
+            const notes = parseFlagValue(argv, i, "--notes");
+            if (notes !== null && notes !== undefined) {
+                if (notes === null) {
+                    return { args: parsed, error: "argument --notes: expected one argument" };
+                }
+                parsed.notes = notes.value;
+                i = notes.next - 1;
+                continue;
+            }
+            const repo = parseFlagValue(argv, i, "--repo");
+            if (repo !== null && repo !== undefined) {
+                if (repo === null) {
+                    return { args: parsed, error: "argument --repo: expected one argument" };
+                }
+                parsed.repo = repo.value;
+                i = repo.next - 1;
+                continue;
+            }
+            const projectRoot = parseFlagValue(argv, i, "--project-root");
+            if (projectRoot !== null && projectRoot !== undefined) {
+                if (projectRoot === null) {
+                    return { args: parsed, error: "argument --project-root: expected one argument" };
+                }
+                parsed.projectRoot = projectRoot.value;
+                i = projectRoot.next - 1;
+                continue;
+            }
+            if (arg === "-h" || arg === "--help") {
+                return { args: parsed, error: "help" };
+            }
+            return { args: parsed, error: `unrecognized arguments: ${arg}` };
+        }
+    }
+    if (!hasUmbrella) {
+        return { args: parsed, error: "the following arguments are required: --umbrella" };
+    }
+    if (!hasChildren) {
+        return { args: parsed, error: "the following arguments are required: --children" };
+    }
+    return { args: parsed };
+}
+function parseList(argv) {
+    let projectRoot = null;
+    let asJson = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            asJson = true;
+            continue;
+        }
+        const root = parseFlagValue(argv, i, "--project-root");
+        if (root !== null && root !== undefined) {
+            if (root === null) {
+                return { projectRoot, asJson, error: "argument --project-root: expected one argument" };
+            }
+            projectRoot = root.value;
+            i = root.next - 1;
+            continue;
+        }
+        if (arg === "-h" || arg === "--help") {
+            return { projectRoot, asJson, error: "help" };
+        }
+        return { projectRoot, asJson, error: `unrecognized arguments: ${arg}` };
+    }
+    return { projectRoot, asJson };
+}
+/** Parse argv mirroring slice_record_existing.py argparse surface. */
+export function parseCli(argv) {
+    let raw = [...argv];
+    if (raw.length > 0 && !["record-existing", "list", "-h", "--help"].includes(raw[0] ?? "")) {
+        raw = ["record-existing", ...raw];
+    }
+    else if (raw.length === 0) {
+        raw = ["record-existing"];
+    }
+    let waveMap = new Map();
+    if (raw[0] === "record-existing") {
+        try {
+            const consumed = consumeWaveFlags(raw);
+            waveMap = consumed.waveMap;
+            raw = consumed.remaining;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                command: "record-existing",
+                waveMap,
+                error: `error: ${msg}`,
+            };
+        }
+    }
+    const command = raw[0];
+    if (command === "-h" || command === "--help") {
+        return { command: "record-existing", waveMap, error: "help" };
+    }
+    if (command === "list") {
+        const parsed = parseList(raw.slice(1));
+        if (parsed.error !== undefined) {
+            return { command: "list", waveMap, error: parsed.error };
+        }
+        return {
+            command: "list",
+            waveMap,
+            listProjectRoot: parsed.projectRoot,
+            listAsJson: parsed.asJson,
+        };
+    }
+    const parsed = parseRecordExisting(raw.slice(1));
+    if (parsed.error !== undefined) {
+        return { command: "record-existing", waveMap, error: parsed.error };
+    }
+    return { command: "record-existing", recordArgs: parsed.args, waveMap };
+}
+/** Run slice CLI and return exit code + captured output. */
+export function runCli(argv) {
+    const parsed = parseCli(argv);
+    if (parsed.error !== undefined) {
+        if (parsed.error === "help") {
+            return { exitCode: 0, stdout: "", stderr: "" };
+        }
+        if (parsed.error.startsWith("error: ")) {
+            return { exitCode: 2, stdout: "", stderr: `${parsed.error}\n` };
+        }
+        return { exitCode: 2, stdout: "", stderr: `error: ${parsed.error}\n` };
+    }
+    if (parsed.command === "list") {
+        const result = runList({
+            projectRoot: parsed.listProjectRoot ?? null,
+            asJson: parsed.listAsJson ?? false,
+        });
+        return result;
+    }
+    if (parsed.recordArgs === undefined) {
+        return { exitCode: 2, stdout: "", stderr: "error: missing record-existing arguments\n" };
+    }
+    const result = runRecordExisting(parsed.recordArgs, parsed.waveMap);
+    return result;
+}
+/** CLI entrypoint writing directly to stdio. */
+export function main(argv) {
+    const result = runCli(argv);
+    if (result.stdout.length > 0) {
+        process.stdout.write(result.stdout);
+    }
+    if (result.stderr.length > 0) {
+        process.stderr.write(result.stderr);
+    }
+    return result.exitCode;
+}
+export const CLI_HELP = "usage: slice_record_existing.py [-h] {record-existing,list} ... (ported TS CLI)";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(main(process.argv.slice(2)));
+}
+//# sourceMappingURL=cli.js.map

package/dist/slice/constants.d.ts

@@ -0,0 +1,18 @@
+/** Default slices log path relative to project root. */
+export declare const DEFAULT_SLICES_LOG_REL_PATH = "vbrief/.eval/slices.jsonl";
+export declare const ENV_PROJECT_ROOT = "DEFT_PROJECT_ROOT";
+export declare const ENV_PROJECT_REPO = "DEFT_PROJECT_REPO";
+export declare const DEFAULT_ACTOR = "manual:operator";
+export declare const DEFAULT_EXPECTED_CLOSE_SIGNAL = "all-children-merged";
+export declare const DEFAULT_ROLE = "manual";
+export declare const VALID_EXPECTED_CLOSE_SIGNALS: Set<string>;
+export declare const REQUIRED_FIELDS: readonly ["slice_id", "umbrella", "umbrella_url", "sliced_at", "actor", "children", "expected_close_signal"];
+export declare const OPTIONAL_FIELDS: readonly ["notes"];
+export declare const ALLOWED_FIELDS: Set<"actor" | "slice_id" | "umbrella" | "umbrella_url" | "sliced_at" | "children" | "expected_close_signal" | "notes">;
+export declare const CHILD_REQUIRED_FIELDS: readonly ["n", "url", "wave", "role"];
+export declare const CHILD_ALLOWED_FIELDS: Set<"n" | "url" | "wave" | "role">;
+export declare const UUID_RE: RegExp;
+export declare const ISO8601_RE: RegExp;
+export declare const WAVE_FLAG_RE: RegExp;
+export declare const PROJECT_ROOT_SENTINELS: readonly ["vbrief", ".git"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/slice/constants.js

@@ -0,0 +1,30 @@
+/** Default slices log path relative to project root. */
+export const DEFAULT_SLICES_LOG_REL_PATH = "vbrief/.eval/slices.jsonl";
+export const ENV_PROJECT_ROOT = "DEFT_PROJECT_ROOT";
+export const ENV_PROJECT_REPO = "DEFT_PROJECT_REPO";
+export const DEFAULT_ACTOR = "manual:operator";
+export const DEFAULT_EXPECTED_CLOSE_SIGNAL = "all-children-merged";
+export const DEFAULT_ROLE = "manual";
+export const VALID_EXPECTED_CLOSE_SIGNALS = new Set([
+    "all-children-merged",
+    "wave-1-merged",
+    "manual",
+]);
+export const REQUIRED_FIELDS = [
+    "slice_id",
+    "umbrella",
+    "umbrella_url",
+    "sliced_at",
+    "actor",
+    "children",
+    "expected_close_signal",
+];
+export const OPTIONAL_FIELDS = ["notes"];
+export const ALLOWED_FIELDS = new Set([...REQUIRED_FIELDS, ...OPTIONAL_FIELDS]);
+export const CHILD_REQUIRED_FIELDS = ["n", "url", "wave", "role"];
+export const CHILD_ALLOWED_FIELDS = new Set(CHILD_REQUIRED_FIELDS);
+export const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+export const ISO8601_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
+export const WAVE_FLAG_RE = /^--wave-(\d+)(?:=(.*))?$/;
+export const PROJECT_ROOT_SENTINELS = ["vbrief", ".git"];
+//# sourceMappingURL=constants.js.map

package/dist/slice/errors.d.ts

@@ -0,0 +1,9 @@
+/** Raised when a record passed to write_slice fails validation. */
+export declare class SliceRecordError extends Error {
+    constructor(message: string);
+}
+/** Raised when an issue number cannot be validated via the SCM shim. */
+export declare class IssueValidationError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/slice/errors.js

@@ -0,0 +1,15 @@
+/** Raised when a record passed to write_slice fails validation. */
+export class SliceRecordError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SliceRecordError";
+    }
+}
+/** Raised when an issue number cannot be validated via the SCM shim. */
+export class IssueValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "IssueValidationError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/slice/existing.d.ts

@@ -0,0 +1,53 @@
+import type { CompletedProcess } from "../scm/call.js";
+import { DEFAULT_ACTOR, DEFAULT_EXPECTED_CLOSE_SIGNAL } from "./constants.js";
+import { appendLock, withAppendLock } from "./lock.js";
+export type ScmCaller = (source: string, verb: string, args: readonly string[] | null, options?: {
+    check?: boolean;
+    captureOutput?: boolean;
+    text?: boolean;
+    timeout?: number;
+}) => CompletedProcess;
+export interface RecordExistingArgs {
+    readonly umbrella: number;
+    readonly children: string;
+    readonly actor: string;
+    readonly expectedCloseSignal: string;
+    readonly slicedAt: string | null;
+    readonly notes: string | null;
+    readonly dryRun: boolean;
+    readonly force: boolean;
+    readonly skipValidation: boolean;
+    readonly repo: string | null;
+    readonly projectRoot: string | null;
+}
+export interface ListArgs {
+    readonly projectRoot: string | null;
+    readonly asJson: boolean;
+}
+export interface ExistingDeps {
+    readonly scm?: ScmCaller;
+    readonly nowIso?: () => string;
+    readonly newSliceId?: () => string;
+    readonly findDuplicateFn?: typeof findDuplicate;
+    readonly withLock?: typeof withAppendLock;
+}
+export declare function parseChildrenCsv(value: string): number[];
+export declare function consumeWaveFlags(rawArgs: string[]): {
+    waveMap: Map<number, number[]>;
+    remaining: string[];
+};
+export declare function repoSlugToUrl(repo: string, n: number): string;
+export declare function buildChildren(children: number[], waveMap: Map<number, number[]>, repo: string): Record<string, unknown>[];
+export declare function childrenSet(record: Record<string, unknown>): Set<number>;
+export declare function findDuplicate(umbrella: number, childrenNumbers: number[], slicesLogPath: string): Record<string, unknown> | null;
+export declare function validateIssueExists(n: number, repo: string, deps?: ExistingDeps): void;
+export declare function summariseWaves(waveMap: Map<number, number[]>, totalChildren: number): string;
+export interface CommandResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export declare function runRecordExisting(args: RecordExistingArgs, waveMap: Map<number, number[]>, deps?: ExistingDeps): CommandResult;
+export declare function runList(args: ListArgs): CommandResult;
+export { appendLock, DEFAULT_ACTOR, DEFAULT_EXPECTED_CLOSE_SIGNAL };
+//# sourceMappingURL=existing.d.ts.map