@nick848/fet 0.1.0 → 1.0.1

package/dist/atomic-write.js

@@ -1,41 +0,0 @@
-import { closeSync, copyFileSync, existsSync, fsyncSync, mkdirSync, openSync, renameSync, writeSync, } from "node:fs";
-import { basename, dirname, join } from "node:path";
-/** DESIGN 14.5: same-dir `*.tmp` then rename (e.g. apply-instructions.md.tmp). */
-export function writeFileAtomicSameDirTmp(targetPath, content) {
-    const dir = dirname(targetPath);
-    const base = basename(targetPath);
-    const tmp = join(dir, `${base}.tmp`);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const fd = openSync(tmp, "w");
-    try {
-        writeSync(fd, content);
-        fsyncSync(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-    renameSync(tmp, targetPath);
-}
-/** Write text atomically: temp file, fsync, rename (same directory). */
-export function writeFileAtomicSync(targetPath, content) {
-    const dir = dirname(targetPath);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const tmp = `${targetPath}.${process.pid}.tmp`;
-    const fd = openSync(tmp, "w");
-    try {
-        writeSync(fd, content);
-        fsyncSync(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-    renameSync(tmp, targetPath);
-}
-export function backupIfExists(filePath) {
-    if (!existsSync(filePath))
-        return;
-    const bak = `${filePath}.bak`;
-    copyFileSync(filePath, bak);
-}

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli.js

@@ -1,178 +0,0 @@
-#!/usr/bin/env node
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { Command } from "commander";
-import { runApply } from "./apply.js";
-import { runDoctor } from "./doctor.js";
-import { assertChangeVerifiedForGate, runOpenSpecWithHooks } from "./hooks.js";
-import { runInit } from "./init.js";
-import { readGlobalState, positionalArgs } from "./state.js";
-import { runUpdateContext } from "./scanner.js";
-import { runValidate } from "./validate.js";
-import { runVerify } from "./verify.js";
-function tailAfter(sub) {
-    const a = process.argv;
-    const i = a.findIndex((v, idx) => idx >= 2 && v === sub);
-    if (i === -1)
-        return [];
-    return a.slice(i + 1);
-}
-function mapNewArgs(rest) {
-    if (rest[0] === "change")
-        return ["new", ...rest];
-    return ["new", "change", ...rest];
-}
-function readPkgVersion() {
-    try {
-        const root = dirname(dirname(fileURLToPath(import.meta.url)));
-        const raw = readFileSync(join(root, "package.json"), "utf8");
-        const j = JSON.parse(raw);
-        return j.version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-}
-const PROXIES = [
-    "explore",
-    "propose",
-    "continue",
-    "ff",
-    "onboard",
-    "list",
-    "view",
-    "spec",
-    "config",
-    "show",
-    "update",
-    "feedback",
-    "status",
-    "instructions",
-    "templates",
-    "schemas",
-    "schema",
-    "change",
-    "completion",
-];
-const WORKFLOW_HINTS = new Set(["continue", "ff", "onboard"]);
-async function main() {
-    const program = new Command();
-    program.name("fet").description("FET — OpenSpec workflow orchestration").version(readPkgVersion());
-    program
-        .command("init")
-        .option("--tool <tool>", "Tooling: cursor | opencode | both (OpenCode: .opencode/skills/*/SKILL.md, see opencode.ai/docs/skills)", "cursor")
-        .option("--force", "overwrite Cursor skills/rules", false)
-        .action(async (opts) => {
-        await runInit(process.cwd(), { tool: opts.tool, force: opts.force });
-    });
-    program.command("doctor").action(() => {
-        runDoctor(process.cwd());
-    });
-    program.command("update-context").action(() => {
-        runUpdateContext(process.cwd());
-    });
-    program.command("apply").action(async () => {
-        await runApply(process.cwd());
-    });
-    program.command("validate").action(async () => {
-        await runValidate(process.cwd());
-    });
-    program
-        .command("verify")
-        .description("Final verification. Default: honest local trust (DESIGN 14.8). --auto runs validate+lint+tsc+test; not a cryptographic audit.")
-        .option("--auto", "run automated verify chain", false)
-        .option("--done", "record manual verify complete", false)
-        .option("--evidence <path>", "optional evidence file for --done")
-        .option("--strict", "strict manual verify (recorded in state)", false)
-        .action(async (opts) => {
-        await runVerify(process.cwd(), {
-            auto: opts.auto,
-            done: opts.done,
-            evidence: opts.evidence,
-            strict: opts.strict,
-        });
-    });
-    program.command("archive").action(async () => {
-        try {
-            const rest = tailAfter("archive");
-            const pos = positionalArgs(rest);
-            const cwd = process.cwd();
-            const gateId = pos.length ? (pos[pos.length - 1] ?? null) : readGlobalState(cwd).activeChangeId;
-            const removeId = gateId ?? readGlobalState(cwd).activeChangeId;
-            const code = await runOpenSpecWithHooks({ cwd }, ["archive", ...rest], {
-                pre: () => {
-                    assertChangeVerifiedForGate(cwd, gateId);
-                },
-                onSuccessRemoveChanges: removeId ? [removeId] : [],
-            });
-            process.exitCode = code;
-        }
-        catch (e) {
-            console.error(e instanceof Error ? e.message : e);
-            process.exitCode = 1;
-        }
-    });
-    program.command("bulk-archive").action(async () => {
-        try {
-            const rest = tailAfter("bulk-archive");
-            const ids = positionalArgs(rest);
-            const cwd = process.cwd();
-            if (!ids.length) {
-                console.error("[fet] bulk-archive requires at least one change id");
-                process.exitCode = 1;
-                return;
-            }
-            for (const id of ids) {
-                assertChangeVerifiedForGate(cwd, id);
-            }
-            const code = await runOpenSpecWithHooks({ cwd }, ["bulk-archive", ...rest], { onSuccessRemoveChanges: ids });
-            process.exitCode = code;
-        }
-        catch (e) {
-            console.error(e instanceof Error ? e.message : e);
-            process.exitCode = 1;
-        }
-    });
-    program.command("sync").action(async () => {
-        try {
-            if (!process.stdin.isTTY) {
-                console.error("[fet] sync requires an interactive terminal for OpenSpec conflict resolution (DESIGN 8.2).");
-                process.exitCode = 1;
-                return;
-            }
-            const rest = tailAfter("sync");
-            const cwd = process.cwd();
-            const pos = positionalArgs(rest);
-            const changeId = pos.length ? (pos[pos.length - 1] ?? null) : readGlobalState(cwd).activeChangeId;
-            const code = await runOpenSpecWithHooks({ cwd }, ["sync", ...rest], {
-                pre: () => {
-                    assertChangeVerifiedForGate(cwd, changeId);
-                },
-            });
-            process.exitCode = code;
-        }
-        catch (e) {
-            console.error(e instanceof Error ? e.message : e);
-            process.exitCode = 1;
-        }
-    });
-    program.command("new").action(async () => {
-        const rest = tailAfter("new");
-        const args = mapNewArgs(rest);
-        const code = await runOpenSpecWithHooks({ cwd: process.cwd() }, args, {});
-        process.exitCode = code;
-    });
-    for (const name of PROXIES) {
-        program.command(name).action(async () => {
-            const rest = tailAfter(name);
-            const code = await runOpenSpecWithHooks({ cwd: process.cwd() }, [name, ...rest], { workflowHint: WORKFLOW_HINTS.has(name) ? name : undefined });
-            process.exitCode = code;
-        });
-    }
-    await program.parseAsync(process.argv);
-}
-main().catch((e) => {
-    console.error(e);
-    process.exitCode = 1;
-});

package/dist/doctor.d.ts

@@ -1 +0,0 @@
-export declare function runDoctor(cwd: string): void;

package/dist/doctor.js

@@ -1,93 +0,0 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { computeCommandFingerprint } from "./fingerprint.js";
-import { getOpenSpecLaunch, openSpecVersionLine } from "./openspec.js";
-import { CONFIG_FILE, GLOBAL_STATE_FILE, changeDir, tasksPath } from "./paths.js";
-import { readChangeState, readGlobalState, reconcileStates, writeGlobalState } from "./state.js";
-const STALE_MS = 1000 * 60 * 60 * 24 * 30;
-const ARTIFACTS = ["proposal.md", "tasks.md", "design.md"];
-export function runDoctor(cwd) {
-    const issues = [];
-    const hints = [];
-    const launch = getOpenSpecLaunch();
-    console.log(`[fet] openspec launch: ${launch.displayPath}`);
-    const ver = openSpecVersionLine();
-    if (ver)
-        console.log(`[fet] openspec version: ${ver}`);
-    else
-        hints.push("Could not read openspec -V (network or npx may be slow)");
-    const gs = join(cwd, GLOBAL_STATE_FILE);
-    if (!existsSync(gs))
-        issues.push(`missing ${GLOBAL_STATE_FILE}`);
-    else {
-        try {
-            JSON.parse(readFileSync(gs, "utf8"));
-        }
-        catch {
-            issues.push(`${GLOBAL_STATE_FILE} is not valid JSON`);
-        }
-    }
-    const agents = join(cwd, "AGENTS.md");
-    if (existsSync(agents)) {
-        const mtime = statSync(agents).mtimeMs;
-        if (Date.now() - mtime > STALE_MS)
-            hints.push("AGENTS.md may be stale — consider fet update-context");
-    }
-    else
-        hints.push("AGENTS.md missing — run fet init / fet update-context");
-    const cfg = join(cwd, CONFIG_FILE);
-    if (existsSync(cfg)) {
-        const mtime = statSync(cfg).mtimeMs;
-        if (Date.now() - mtime > STALE_MS)
-            hints.push("openspec/config.yaml may be stale — consider fet update-context");
-    }
-    let g = readGlobalState(cwd);
-    const rec = reconcileStates(cwd, g);
-    g = rec.global;
-    writeGlobalState(cwd, g);
-    for (const w of rec.warnings)
-        hints.push(w);
-    const active = g.activeChangeId;
-    if (active) {
-        const cs = readChangeState(cwd, active);
-        if (cs?.verify?.status !== "done") {
-            hints.push(`Active change "${active}" is not verified — archive/sync will be blocked until fet verify --done or --auto`);
-        }
-        const changeRoot = join(cwd, changeDir(active));
-        if (existsSync(changeRoot)) {
-            for (const a of ARTIFACTS) {
-                const ap = join(changeRoot, a);
-                if (!existsSync(ap))
-                    hints.push(`Change "${active}" missing artifact: ${a} (optional depending on workflow)`);
-            }
-            const tp = join(cwd, tasksPath(active));
-            if (!existsSync(tp))
-                hints.push(`Change "${active}" has no tasks.md yet`);
-        }
-    }
-    const fp = computeCommandFingerprint(cwd);
-    if (g.autoRunApproval && g.autoRunApproval.commandFingerprint !== fp) {
-        hints.push("package.json scripts changed since last auto-run approval — next validate/verify --auto will re-prompt");
-    }
-    const cursorSkills = join(cwd, ".cursor", "skills");
-    if (!existsSync(cursorSkills))
-        hints.push("Cursor skills missing — run fet init --tool cursor");
-    const opencodeSkills = join(cwd, ".opencode", "skills");
-    if (!existsSync(opencodeSkills)) {
-        hints.push("OpenCode skills missing — run fet init --tool opencode (see https://opencode.ai/docs/skills )");
-    }
-    if (issues.length) {
-        console.error("[fet] doctor: issues:");
-        for (const i of issues)
-            console.error(`  - ${i}`);
-        process.exitCode = 1;
-    }
-    else {
-        console.log("[fet] doctor: no blocking issues.");
-    }
-    if (hints.length) {
-        console.log("[fet] doctor: hints:");
-        for (const h of hints)
-            console.log(`  - ${h}`);
-    }
-}

package/dist/fingerprint.d.ts

@@ -1,6 +0,0 @@
-/** Collect script literals for validate/verify-auto (DESIGN 14.7, monorepo workspaces). */
-export declare function collectScriptFingerprintParts(cwd: string): {
-    parts: string[];
-    lockfileHints: string[];
-};
-export declare function computeCommandFingerprint(cwd: string): string;

package/dist/fingerprint.js

@@ -1,77 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join, relative } from "node:path";
-function stableSerialize(obj) {
-    return JSON.stringify(obj, Object.keys(obj).sort());
-}
-function workspacePackageJsonFiles(cwd) {
-    const out = [];
-    const pkgPath = join(cwd, "package.json");
-    if (!existsSync(pkgPath))
-        return out;
-    try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-        const patterns = Array.isArray(pkg.workspaces)
-            ? pkg.workspaces
-            : (pkg.workspaces?.packages ?? []);
-        for (const pat of patterns) {
-            if (typeof pat !== "string")
-                continue;
-            if (pat.includes("*")) {
-                const packagesDir = join(cwd, "packages");
-                if (existsSync(packagesDir)) {
-                    for (const name of readdirSync(packagesDir)) {
-                        const p = join(packagesDir, name, "package.json");
-                        if (existsSync(p))
-                            out.push(p);
-                    }
-                }
-            }
-            else {
-                const p = join(cwd, pat, "package.json");
-                if (existsSync(p))
-                    out.push(p);
-            }
-        }
-    }
-    catch {
-        /* skip */
-    }
-    return out;
-}
-function scriptsFingerprintSlice(pkgPath, cwd) {
-    try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-        const scripts = pkg.scripts ?? {};
-        const keys = ["test", "lint", "build"].filter((k) => scripts[k] != null);
-        const ordered = {};
-        for (const k of keys.sort())
-            ordered[k] = scripts[k] ?? "";
-        const rel = relative(cwd, pkgPath).replace(/\\/g, "/");
-        return `${rel}:${stableSerialize(ordered)}`;
-    }
-    catch {
-        return `${pkgPath}:{}`;
-    }
-}
-/** Collect script literals for validate/verify-auto (DESIGN 14.7, monorepo workspaces). */
-export function collectScriptFingerprintParts(cwd) {
-    const parts = [];
-    const rootPkg = join(cwd, "package.json");
-    if (existsSync(rootPkg)) {
-        parts.push(scriptsFingerprintSlice(rootPkg, cwd));
-    }
-    for (const ws of workspacePackageJsonFiles(cwd)) {
-        parts.push(scriptsFingerprintSlice(ws, cwd));
-    }
-    const lockfiles = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"].filter((f) => existsSync(join(cwd, f)));
-    parts.push(...lockfiles.map((f) => `lock:${f}`));
-    return { parts, lockfileHints: lockfiles };
-}
-export function computeCommandFingerprint(cwd) {
-    const { parts } = collectScriptFingerprintParts(cwd);
-    const h = createHash("sha256");
-    for (const p of parts.sort())
-        h.update(p + "\n");
-    return h.digest("hex");
-}

package/dist/hooks.d.ts

@@ -1,12 +0,0 @@
-export type HookContext = {
-    cwd: string;
-};
-export declare function runOpenSpecWithHooks(ctx: HookContext, openspecArgs: string[], hooks?: {
-    pre?: () => Promise<void> | void;
-    post?: (exitCode: number) => Promise<void> | void;
-    /** DESIGN 5.3: after exit 0, remove these change ids from global fet-state */
-    onSuccessRemoveChanges?: string[];
-    workflowHint?: string;
-}): Promise<number>;
-/** DESIGN 7.1 / 4: gate archive and sync on verify when using fet entry. */
-export declare function assertChangeVerifiedForGate(cwd: string, changeId: string | null): void;

package/dist/hooks.js

@@ -1,47 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { printWorkflowHint } from "./workflow-hints.js";
-import { spawnOpenSpec } from "./openspec.js";
-import { changeDir } from "./paths.js";
-import { readChangeState, readGlobalState, reconcileStates, removeArchivedChangesFromGlobal, writeGlobalState, } from "./state.js";
-export async function runOpenSpecWithHooks(ctx, openspecArgs, hooks = {}) {
-    let global = readGlobalState(ctx.cwd);
-    const rec = reconcileStates(ctx.cwd, global);
-    global = rec.global;
-    if (rec.warnings.length) {
-        for (const w of rec.warnings)
-            console.error(`[fet] ${w}`);
-    }
-    writeGlobalState(ctx.cwd, global);
-    if (hooks.pre)
-        await hooks.pre();
-    const code = await spawnOpenSpec(openspecArgs, { cwd: ctx.cwd, inheritStdio: true });
-    if (hooks.post)
-        await hooks.post(code);
-    if (code === 0 && hooks.onSuccessRemoveChanges?.length) {
-        let g = readGlobalState(ctx.cwd);
-        g = removeArchivedChangesFromGlobal(g, hooks.onSuccessRemoveChanges);
-        writeGlobalState(ctx.cwd, g);
-    }
-    if (code === 0 && hooks.workflowHint)
-        printWorkflowHint(hooks.workflowHint);
-    const again = readGlobalState(ctx.cwd);
-    const rec2 = reconcileStates(ctx.cwd, again);
-    writeGlobalState(ctx.cwd, rec2.global);
-    return code;
-}
-/** DESIGN 7.1 / 4: gate archive and sync on verify when using fet entry. */
-export function assertChangeVerifiedForGate(cwd, changeId) {
-    let id = changeId;
-    if (!id)
-        id = readGlobalState(cwd).activeChangeId;
-    if (!id)
-        return;
-    const changePath = join(cwd, changeDir(id));
-    if (!existsSync(changePath))
-        return;
-    const cs = readChangeState(cwd, id);
-    if (!cs || cs.verify?.status !== "done") {
-        throw new Error(`[fet] Change "${id}" is not verified. Complete fet verify (or fet verify --done) before archive/sync. Direct openspec calls are not gated.`);
-    }
-}

package/dist/init.d.ts

@@ -1,4 +0,0 @@
-export declare function runInit(cwd: string, opts: {
-    tool?: string;
-    force?: boolean;
-}): Promise<void>;

package/dist/init.js

@@ -1,47 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { getOpenSpecLaunch, resolveOpenSpecExecutable, spawnOpenSpec } from "./openspec.js";
-import { GLOBAL_STATE_FILE } from "./paths.js";
-import { defaultGlobalState, writeGlobalState } from "./state.js";
-import { mergeConfigYaml, scanProject, writeAgentsMd } from "./scanner.js";
-import { generateOpenCodeTooling } from "./opencode-skills.js";
-import { generateCursorTooling } from "./skills.js";
-export async function runInit(cwd, opts) {
-    const launch = getOpenSpecLaunch();
-    if (!resolveOpenSpecExecutable()) {
-        console.warn(`[fet] Global openspec not on PATH; using: ${launch.displayPath}`);
-    }
-    const code = await spawnOpenSpec(["init"], { cwd, inheritStdio: true });
-    if (code !== 0) {
-        process.exitCode = code;
-        return;
-    }
-    const openspecDir = join(cwd, "openspec");
-    if (!existsSync(openspecDir))
-        mkdirSync(openspecDir, { recursive: true });
-    const gsPath = join(cwd, GLOBAL_STATE_FILE);
-    if (!existsSync(gsPath)) {
-        writeGlobalState(cwd, defaultGlobalState());
-    }
-    const scan = scanProject(cwd);
-    for (const w of scan.warnings)
-        console.warn(`[fet] ${w}`);
-    writeAgentsMd(cwd, scan);
-    mergeConfigYaml(cwd, scan);
-    const tool = opts.tool ?? "cursor";
-    const force = opts.force ?? false;
-    if (tool === "cursor") {
-        await generateCursorTooling(cwd, { force });
-    }
-    else if (tool === "opencode") {
-        await generateOpenCodeTooling(cwd, { force });
-    }
-    else if (tool === "both") {
-        await generateCursorTooling(cwd, { force });
-        await generateOpenCodeTooling(cwd, { force });
-    }
-    else {
-        console.warn(`[fet] Unknown --tool "${tool}". Use: cursor | opencode | both (see https://opencode.ai/docs/skills )`);
-    }
-    console.log("[fet] init complete.");
-}

package/dist/opencode-skills.d.ts

@@ -1,3 +0,0 @@
-export declare function generateOpenCodeTooling(cwd: string, opts: {
-    force: boolean;
-}): Promise<void>;