@deftai/directive-core 0.55.0

package/dist/doctor/paths.js

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFT_REPO_POSITIVE_MARKERS } from "./constants.js";
+/** Resolve a user-supplied path string to an absolute path. */
+export function resolvePath(pathStr, cwd = process.cwd()) {
+    if (!pathStr) {
+        return cwd;
+    }
+    const expanded = pathStr.startsWith("~")
+        ? join(process.env.HOME ?? cwd, pathStr.slice(1))
+        : pathStr;
+    return resolve(cwd, expanded);
+}
+/** Best-effort version string (mirrors Python `_resolve_version`). */
+export function resolveVersion(frameworkRoot) {
+    const root = frameworkRoot ?? resolveDefaultFrameworkRoot();
+    const candidates = [
+        join(root, "VERSION"),
+        join(root, "scripts", "VERSION"),
+        join(process.cwd(), ".deft-version"),
+    ];
+    for (const cand of candidates) {
+        try {
+            if (existsSync(cand)) {
+                return readFileSync(cand, "utf8").trim();
+            }
+        }
+        catch {
+            // continue
+        }
+    }
+    return "dev";
+}
+/** Return the deft framework repo root (the directory containing `main.md`). */
+export function resolveDefaultFrameworkRoot() {
+    const envRoot = process.env.DEFT_ROOT?.trim();
+    if (envRoot) {
+        return resolve(envRoot);
+    }
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i += 1) {
+        // #1875: templates/ moved under content/ in the source repo; main.md stays
+        // at root. Accept either layout (source checkout vs flattened deposit).
+        if (existsSync(join(dir, "main.md")) &&
+            (existsSync(join(dir, "content", "templates", "agents-entry.md")) ||
+                existsSync(join(dir, "templates", "agents-entry.md")))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..");
+}
+/** Directory containing doctor implementation (Python: scripts/). */
+export function resolveScriptDir(frameworkRoot) {
+    return join(frameworkRoot ?? resolveDefaultFrameworkRoot(), "scripts");
+}
+export function readTextSafe(path, readText = defaultReadText) {
+    return readText(path);
+}
+function defaultReadText(path) {
+    try {
+        if (!existsSync(path)) {
+            return null;
+        }
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function defaultIsFile(p) {
+    try {
+        return statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function defaultIsDir(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function runningInsideDeftRepo(projectRoot, seams = {}) {
+    const fileCheck = seams.isFile ?? defaultIsFile;
+    const dirCheck = seams.isDir ?? defaultIsDir;
+    if (!fileCheck(join(projectRoot, "main.md"))) {
+        return false;
+    }
+    if (dirCheck(join(projectRoot, "deft"))) {
+        return false;
+    }
+    if (dirCheck(join(projectRoot, ".deft", "core"))) {
+        return false;
+    }
+    return DEFT_REPO_POSITIVE_MARKERS.every((m) => fileCheck(join(projectRoot, m)));
+}
+//# sourceMappingURL=paths.js.map

package/dist/doctor/payload-staleness.d.ts

@@ -0,0 +1,13 @@
+import type { OutputSink } from "./output.js";
+import type { Finding } from "./types.js";
+export interface PayloadStalenessSeams {
+    readonly readText?: (path: string) => string | null;
+    readonly isFile?: (path: string) => boolean;
+    readonly frameworkRoot?: string;
+    readonly runGitLsRemote?: (deftDir: string, ref: string) => {
+        ok: boolean;
+        stdout: string;
+    };
+}
+export declare function runPayloadStalenessCheck(projectRoot: string, sink: OutputSink, addFinding: (finding: Finding) => void, seams?: PayloadStalenessSeams): void;
+//# sourceMappingURL=payload-staleness.d.ts.map

package/dist/doctor/payload-staleness.js

@@ -0,0 +1,165 @@
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { CANONICAL_UPGRADE_COMMAND } from "./constants.js";
+import { locateManifest, parseInstallManifest } from "./manifest.js";
+import { readTextSafe, resolveDefaultFrameworkRoot } from "./paths.js";
+function isDeftFrameworkRepo(projectRoot, readText = readTextSafe) {
+    try {
+        const agents = join(projectRoot, "AGENTS.md");
+        const text = readText(agents);
+        return text !== null && text.includes("Deft — Development Framework (deft repo)");
+    }
+    catch {
+        return false;
+    }
+}
+function parseRemoteSha(stdout) {
+    let remoteSha = "";
+    let peeledSha = "";
+    for (const line of stdout.split("\n")) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 2) {
+            const refname = parts[1] ?? "";
+            if (refname.endsWith("^{}")) {
+                peeledSha = parts[0] ?? "";
+            }
+            else if (!remoteSha) {
+                remoteSha = parts[0] ?? "";
+            }
+        }
+    }
+    if (peeledSha) {
+        return peeledSha;
+    }
+    if (remoteSha) {
+        return remoteSha;
+    }
+    const firstLine = stdout.split("\n").find((ln) => ln.trim()) ?? "";
+    return firstLine.trim().split(/\s+/)[0] ?? "";
+}
+export function runPayloadStalenessCheck(projectRoot, sink, addFinding, seams = {}) {
+    const checkName = "payload-staleness";
+    const readText = seams.readText ?? readTextSafe;
+    const isFile = seams.isFile ?? ((p) => readText(p) !== null);
+    if (isDeftFrameworkRepo(projectRoot, readText)) {
+        sink.info(`${checkName}: skip -- running inside deft framework repo`);
+        addFinding({
+            severity: "skip",
+            message: "inside framework repo (no install manifest)",
+            check: checkName,
+            status: "skip",
+        });
+        return;
+    }
+    const frameworkRoot = seams.frameworkRoot ?? resolveDefaultFrameworkRoot();
+    let manifestPath = join(frameworkRoot, "VERSION");
+    if (!isFile(manifestPath)) {
+        manifestPath = locateManifest(projectRoot, null, isFile);
+    }
+    if (manifestPath === null) {
+        const legacyMarker = join(projectRoot, ".deft-version");
+        if (isFile(legacyMarker)) {
+            manifestPath = legacyMarker;
+        }
+    }
+    if (manifestPath === null || !isFile(manifestPath)) {
+        sink.info(`${checkName}: skip -- no install manifest found (pre-v0.28 or legacy state)`);
+        addFinding({ severity: "skip", message: "no manifest", check: checkName, status: "skip" });
+        return;
+    }
+    const text = readText(manifestPath);
+    if (text === null) {
+        sink.info(`${checkName}: skip -- could not read manifest`);
+        addFinding({
+            severity: "skip",
+            message: "manifest unreadable",
+            check: checkName,
+            status: "skip",
+        });
+        return;
+    }
+    const manifest = parseInstallManifest(text);
+    const installedSha = (manifest.sha ?? "").trim();
+    const ref = (manifest.ref ?? manifest.tag ?? "").trim();
+    if (!installedSha) {
+        sink.info(`${checkName}: skip -- manifest has no sha (incomplete provenance)`);
+        addFinding({
+            severity: "skip",
+            message: "no sha in manifest",
+            check: checkName,
+            status: "skip",
+        });
+        return;
+    }
+    if (!ref) {
+        sink.info(`${checkName}: skip -- manifest has no ref or tag (cannot resolve remote sha)`);
+        addFinding({
+            severity: "skip",
+            message: "no ref/tag in manifest",
+            check: checkName,
+            status: "skip",
+        });
+        return;
+    }
+    const deftDir = dirname(manifestPath);
+    const runLsRemote = seams.runGitLsRemote ??
+        ((dir, r) => {
+            const proc = spawnSync("git", ["-C", dir, "ls-remote", "origin", r], {
+                encoding: "utf8",
+                timeout: 15_000,
+            });
+            return { ok: proc.status === 0, stdout: proc.stdout ?? "" };
+        });
+    let remoteResult;
+    try {
+        remoteResult = runLsRemote(deftDir, ref);
+    }
+    catch {
+        sink.info(`${checkName}: skip -- could not probe remote (Error)`);
+        addFinding({
+            severity: "skip",
+            message: "remote probe failed",
+            check: checkName,
+            status: "skip",
+        });
+        return;
+    }
+    if (!remoteResult.ok) {
+        sink.info(`${checkName}: skip -- git ls-remote failed (no network or no origin)`);
+        addFinding({
+            severity: "skip",
+            message: "ls-remote unavailable",
+            check: checkName,
+            status: "skip",
+        });
+        return;
+    }
+    const remoteSha = parseRemoteSha(remoteResult.stdout);
+    if (!remoteSha) {
+        sink.info(`${checkName}: skip -- ls-remote produced no sha`);
+        addFinding({
+            severity: "skip",
+            message: "no remote sha",
+            check: checkName,
+            status: "skip",
+        });
+        return;
+    }
+    if (installedSha === remoteSha) {
+        sink.info(`${checkName}: current (sha matches remote)`);
+        return;
+    }
+    const msg = `Framework payload is stale (installed sha ${installedSha.slice(0, 8)}... behind remote ${remoteSha.slice(0, 8)}... for ref '${ref}'). Recommendation: run the canonical headless upgrader \`${CANONICAL_UPGRADE_COMMAND}\` from your project root to pull the latest payload (drop \`--json\` for human-readable output). On an installer binary predating the headless flags, download the latest deft-install from GitHub Releases first.`;
+    sink.warn(msg);
+    addFinding({
+        severity: "warning",
+        message: msg,
+        check: checkName,
+        status: "stale",
+        installed_sha: installedSha,
+        remote_sha: remoteSha,
+        ref,
+        suggestion: CANONICAL_UPGRADE_COMMAND,
+    });
+}
+//# sourceMappingURL=payload-staleness.js.map

package/dist/doctor/taskfile.d.ts

@@ -0,0 +1,6 @@
+export declare function includesBlockHasDeftTaskfile(text: string): boolean;
+export declare function resolveConsumerTaskfile(projectRoot: string): string | null;
+export type TaskfileIncludeStatus = "ok" | "missing-file" | "missing-include" | "unreadable";
+export declare function classifyTaskfileInclude(projectRoot: string): TaskfileIncludeStatus;
+export declare function formatMissingIncludeSnippet(): string;
+//# sourceMappingURL=taskfile.d.ts.map

package/dist/doctor/taskfile.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const TASKFILE_INCLUDES_KEY_RE = /^(?<indent>[\t ]*)includes\s*:\s*(?:#.*)?$/i;
+const TASKFILE_INCLUDE_VALUE_RE = /^[\t ]+taskfile\s*:\s*["']?\.?\/(?:\.deft\/core|deft)\/Taskfile\.ya?ml["']?\s*(?:#.*)?$/i;
+export function includesBlockHasDeftTaskfile(text) {
+    let includesIndent = null;
+    let inIncludes = false;
+    for (const rawLine of text.split("\n")) {
+        const stripped = rawLine.trim();
+        if (!stripped || stripped.startsWith("#")) {
+            continue;
+        }
+        const indent = rawLine.length - rawLine.trimStart().length;
+        if (!inIncludes) {
+            const match = TASKFILE_INCLUDES_KEY_RE.exec(rawLine);
+            if (match !== null && indent === 0) {
+                includesIndent = indent;
+                inIncludes = true;
+            }
+            continue;
+        }
+        if (indent <= (includesIndent ?? 0)) {
+            inIncludes = false;
+            const match = TASKFILE_INCLUDES_KEY_RE.exec(rawLine);
+            if (match !== null && indent === 0) {
+                includesIndent = indent;
+                inIncludes = true;
+            }
+            continue;
+        }
+        if (TASKFILE_INCLUDE_VALUE_RE.test(rawLine)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function resolveConsumerTaskfile(projectRoot) {
+    for (const name of ["Taskfile.yml", "Taskfile.yaml"]) {
+        const candidate = join(projectRoot, name);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function classifyTaskfileInclude(projectRoot) {
+    const taskfile = resolveConsumerTaskfile(projectRoot);
+    if (taskfile === null) {
+        return "missing-file";
+    }
+    try {
+        const text = readFileSync(taskfile, "utf8").replace(/^\uFEFF/, "");
+        if (includesBlockHasDeftTaskfile(text)) {
+            return "ok";
+        }
+        return "missing-include";
+    }
+    catch {
+        return "unreadable";
+    }
+}
+export function formatMissingIncludeSnippet() {
+    return "  deft:\n    taskfile: ./.deft/core/Taskfile.yml\n    optional: true\n";
+}
+//# sourceMappingURL=taskfile.js.map

package/dist/doctor/types.d.ts

@@ -0,0 +1,76 @@
+export declare const EXIT_CLEAN = 0;
+export declare const EXIT_DRIFT = 1;
+export declare const EXIT_CONFIG_ERROR = 2;
+export type CheckStatus = "pass" | "fail" | "skip" | "error";
+export interface CheckResult {
+    readonly name: string;
+    readonly status: CheckStatus;
+    readonly detail: string;
+    readonly data?: Readonly<Record<string, unknown>>;
+}
+export interface DoctorResult {
+    readonly projectRoot: string;
+    readonly installRoot: string | null;
+    readonly exitCode: number;
+    readonly checks: readonly CheckResult[];
+    readonly errors: readonly string[];
+}
+export interface Finding {
+    readonly severity: "error" | "warning" | "skip";
+    readonly message: string;
+    readonly check?: string;
+    readonly tool?: string;
+    readonly suggestion?: string | null;
+    readonly status?: string;
+    readonly [key: string]: unknown;
+}
+export interface DoctorFlags {
+    readonly session: boolean;
+    readonly fix: boolean;
+    readonly json: boolean;
+    readonly quiet: boolean;
+    readonly full: boolean;
+    readonly help: boolean;
+    readonly projectRoot: string | null;
+    readonly unknown: readonly string[];
+}
+export interface ThrottleDecision {
+    readonly skip: boolean;
+    readonly dirty: boolean;
+    readonly lastRunAt: Date | null;
+    readonly lastExitCode: number;
+    readonly lastFindingCount: number;
+    readonly lastErrorCount: number;
+    readonly nextEligibleAt: Date | null;
+    readonly ageHours: number;
+}
+export interface DoctorState {
+    readonly lastRunAt: Date;
+    readonly lastExitCode: number;
+    readonly lastFindingCount: number;
+    readonly lastErrorCount: number;
+}
+export interface DoctorSeams {
+    readonly whichFn?: (cmd: string) => string | null;
+    readonly frameworkRoot?: string;
+    readonly readText?: (path: string) => string | null;
+    readonly isDir?: (path: string) => boolean;
+    readonly isFile?: (path: string) => boolean;
+    readonly runGitLsRemote?: (deftDir: string, ref: string) => {
+        ok: boolean;
+        stdout: string;
+    };
+    readonly agentsRefreshPlan?: (projectRoot: string) => Record<string, unknown>;
+    readonly readState?: (projectRoot: string) => DoctorState | null;
+    readonly writeState?: (projectRoot: string, payload: {
+        exitCode: number;
+        findingCount: number;
+        errorCount: number;
+        now?: Date;
+    }) => string | null;
+    readonly isTty?: () => boolean;
+    readonly readYn?: (prompt: string, defaultYes: boolean) => boolean;
+    readonly writeText?: (path: string, content: string) => void;
+    readonly now?: () => Date;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/doctor/types.js

@@ -0,0 +1,4 @@
+export const EXIT_CLEAN = 0;
+export const EXIT_DRIFT = 1;
+export const EXIT_CONFIG_ERROR = 2;
+//# sourceMappingURL=types.js.map

package/dist/doctor/which.d.ts

@@ -0,0 +1,3 @@
+/** Default PATH lookup mirroring Python `shutil.which`. */
+export declare function defaultWhich(name: string): string | null;
+//# sourceMappingURL=which.d.ts.map

package/dist/doctor/which.js

@@ -0,0 +1,17 @@
+import { execFileSync } from "node:child_process";
+/** Default PATH lookup mirroring Python `shutil.which`. */
+export function defaultWhich(name) {
+    const locator = process.platform === "win32" ? "where" : "which";
+    try {
+        const result = execFileSync(locator, [name], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const first = result.split(/\r?\n/).find((line) => line.trim().length > 0);
+        return first !== undefined ? first.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=which.js.map

package/dist/encoding/evaluate.d.ts

@@ -0,0 +1,19 @@
+import { type Finding } from "./scan.js";
+export type ScanMode = "all" | "staged";
+/** Result of an encoding-gate evaluation; mirrors the Python `evaluate` tuple. */
+export interface EvaluateResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly findings: Finding[];
+    readonly message: string;
+}
+export interface EvaluateOptions {
+    readonly mode?: ScanMode;
+    readonly allowListPath?: string | null;
+}
+/**
+ * Pure evaluation returning `{ exitCode, findings, message }`. Three-state
+ * exit (0 clean / 1 corruption / 2 config error), faithful to the Python
+ * `verify_encoding.evaluate`.
+ */
+export declare function evaluate(projectRoot: string, options?: EvaluateOptions): EvaluateResult;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/encoding/evaluate.js

@@ -0,0 +1,155 @@
+import { readFileSync, statSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { GitCommandError, GitNotFoundError, gitStagedFiles, gitTrackedFiles } from "./git.js";
+import { BUILTIN_ALLOW_LIST, SCANNABLE_EXTENSIONS } from "./patterns.js";
+import { renderFinding, scanFile, suffixOf } from "./scan.js";
+import { fnmatchCase } from "./text.js";
+/** Raised by `loadAllowList` when the path does not exist. */
+class AllowListNotFoundError extends Error {
+}
+function loadAllowList(path) {
+    if (path === null || path === undefined) {
+        return [];
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            throw new AllowListNotFoundError(path);
+        }
+        throw err;
+    }
+    const out = [];
+    for (const line of raw.split(/\r\n|[\n\r]/)) {
+        const stripped = line.trim();
+        if (stripped.length === 0 || stripped.startsWith("#")) {
+            continue;
+        }
+        out.push(stripped);
+    }
+    return out;
+}
+function isAllowListed(relPath, patterns) {
+    return patterns.some((pat) => fnmatchCase(relPath, pat));
+}
+function isFile(fullPath) {
+    try {
+        return statSync(fullPath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function filterScannable(relPaths, projectRoot, allowGlobs) {
+    const out = [];
+    const rootResolved = resolve(projectRoot);
+    for (const rel of relPaths) {
+        const posix = rel.replace(/\\/g, "/");
+        const full = resolve(rootResolved, rel);
+        const relCheck = relative(rootResolved, full);
+        if (relCheck.startsWith("..") || isAbsolute(relCheck)) {
+            continue;
+        }
+        if (!isFile(full)) {
+            continue;
+        }
+        if (!SCANNABLE_EXTENSIONS.has(suffixOf(full))) {
+            continue;
+        }
+        if (isAllowListed(posix, allowGlobs)) {
+            continue;
+        }
+        out.push([posix, full]);
+    }
+    return out;
+}
+/**
+ * Pure evaluation returning `{ exitCode, findings, message }`. Three-state
+ * exit (0 clean / 1 corruption / 2 config error), faithful to the Python
+ * `verify_encoding.evaluate`.
+ */
+export function evaluate(projectRoot, options = {}) {
+    const mode = options.mode ?? "all";
+    if (mode !== "all" && mode !== "staged") {
+        return {
+            exitCode: 2,
+            findings: [],
+            message: `verify_encoding: unrecognised mode '${mode}' (expected 'all' or 'staged').`,
+        };
+    }
+    let customGlobs;
+    try {
+        customGlobs = loadAllowList(options.allowListPath);
+    }
+    catch (err) {
+        if (err instanceof AllowListNotFoundError) {
+            return {
+                exitCode: 2,
+                findings: [],
+                message: `verify_encoding: --allow-list file not found: ${err.message}\n` +
+                    "  Recovery: pass an existing path or omit the flag.",
+            };
+        }
+        return {
+            exitCode: 2,
+            findings: [],
+            message: `verify_encoding: --allow-list unreadable: ${String(err.message)}\n` +
+                "  Recovery: check file permissions.",
+        };
+    }
+    const allowGlobs = [...BUILTIN_ALLOW_LIST, ...customGlobs];
+    let relPaths;
+    try {
+        relPaths = mode === "staged" ? gitStagedFiles(projectRoot) : gitTrackedFiles(projectRoot);
+    }
+    catch (err) {
+        if (err instanceof GitNotFoundError) {
+            return {
+                exitCode: 2,
+                findings: [],
+                message: "verify_encoding: 'git' executable not found on PATH.\n" +
+                    "  Recovery: install git or run inside a git working tree.",
+            };
+        }
+        if (err instanceof GitCommandError) {
+            return {
+                exitCode: 2,
+                findings: [],
+                message: `verify_encoding: git failed -- ${err.message}\n` +
+                    "  Recovery: ensure --project-root points at a git working tree.",
+            };
+        }
+        throw err;
+    }
+    const candidates = filterScannable(relPaths, projectRoot, allowGlobs);
+    const findings = [];
+    for (const [rel, full] of candidates) {
+        findings.push(...scanFile(rel, full));
+    }
+    if (findings.length > 0) {
+        const fileCount = new Set(findings.map((f) => f.path)).size;
+        const header = `verify_encoding: detected ${findings.length} mojibake / ` +
+            `U+FFFD / unexpected-BOM hit(s) across ${fileCount} file(s) (#798).\n` +
+            "  Root cause: a Windows codepage (cp1252/cp437) decoded the bytes on the READ side\n" +
+            "  before any safe write could preserve them. Fix: rewrite the offending files with\n" +
+            "  UTF-8, re-read from a clean source (git checkout HEAD -- <path>), and do NOT\n" +
+            "  round-trip through PowerShell 5.1 again. See AGENTS.md ## PowerShell.\n" +
+            "  Allow-list a documented exception via --allow-list <path>.";
+        const shown = findings.slice(0, 50).map(renderFinding);
+        let body = shown.join("\n");
+        if (findings.length > 50) {
+            body += `\n  ... and ${findings.length - 50} more`;
+        }
+        return { exitCode: 1, findings, message: `${header}\n${body}` };
+    }
+    return {
+        exitCode: 0,
+        findings,
+        message: `verify_encoding: ${candidates.length} file(s) clean -- no mojibake / ` +
+            "U+FFFD / unexpected-BOM detected (#798).",
+    };
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/encoding/git.d.ts

@@ -0,0 +1,11 @@
+/** Raised when `git` is not on PATH (caller maps to exit 2). */
+export declare class GitNotFoundError extends Error {
+}
+/** Raised when a `git` invocation exits non-zero (caller maps to exit 2). */
+export declare class GitCommandError extends Error {
+}
+/** Return `git ls-files` output as a list of POSIX-form rel paths. */
+export declare function gitTrackedFiles(projectRoot: string): string[];
+/** Return `git diff --cached --name-only` output as POSIX-form rel paths. */
+export declare function gitStagedFiles(projectRoot: string): string[];
+//# sourceMappingURL=git.d.ts.map

package/dist/encoding/git.js

@@ -0,0 +1,36 @@
+import { execFileSync } from "node:child_process";
+/** Raised when `git` is not on PATH (caller maps to exit 2). */
+export class GitNotFoundError extends Error {
+}
+/** Raised when a `git` invocation exits non-zero (caller maps to exit 2). */
+export class GitCommandError extends Error {
+}
+function runGit(args, projectRoot) {
+    try {
+        return execFileSync("git", args, {
+            cwd: projectRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            throw new GitNotFoundError("'git' executable not found on PATH");
+        }
+        const stderr = typeof e.stderr === "string" ? e.stderr.trim() : String(e.message ?? err);
+        throw new GitCommandError(`git ${args.join(" ")} failed: ${stderr}`);
+    }
+}
+function splitLines(stdout) {
+    return stdout.split("\n").filter((line) => line.trim().length > 0);
+}
+/** Return `git ls-files` output as a list of POSIX-form rel paths. */
+export function gitTrackedFiles(projectRoot) {
+    return splitLines(runGit(["ls-files"], projectRoot));
+}
+/** Return `git diff --cached --name-only` output as POSIX-form rel paths. */
+export function gitStagedFiles(projectRoot) {
+    return splitLines(runGit(["diff", "--cached", "--name-only", "--diff-filter=ACMR"], projectRoot));
+}
+//# sourceMappingURL=git.js.map