@gr8ful/spf 0.5.1 → 0.7.0

package/dist/test/paths.test.js

@@ -1,68 +0,0 @@
-/**
- * Regression guard for `resolveDataPaths`'s self-heal: a `data_dir` that
- * exists as a broken symlink (self-referential or dangling) must be removed
- * before anything tries to `mkdirSync` through it — see `paths.ts`'s
- * `healBrokenDataDir` for why this lives here and not at each `mkdirSync`
- * call site individually. This is a live bug that shipped once already: a
- * self-referential `.spf/data -> .spf/data` symlink was observed on a real
- * checkout, and every subsequent command failed with `ELOOP` at its very
- * first filesystem touch.
- */
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { resolveAnchor, resolveDataPaths } from "../core/paths.js";
-let dir;
-beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "spf-paths-test-"));
-});
-afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-});
-test("resolveDataPaths: a self-referential data_dir symlink is removed, not left to ELOOP later", () => {
-    const dataDir = join(dir, ".spf", "data");
-    mkdirSync(join(dir, ".spf"), { recursive: true });
-    symlinkSync(dataDir, dataDir, "dir"); // exactly the observed bug: points at itself
-    const anchor = resolveAnchor(dir);
-    const paths = resolveDataPaths(anchor, ".spf/data", ".spf/data/spf.db");
-    assert.equal(paths.data_dir, dataDir);
-    assert.equal(existsSync(dataDir), false, "the broken symlink must be gone, not just tolerated");
-    // Confirms the actual failure mode is fixed: this would throw ELOOP before the fix.
-    mkdirSync(dataDir, { recursive: true });
-    assert.ok(existsSync(dataDir));
-});
-test("resolveDataPaths: a dangling data_dir symlink (target removed) is also cleaned up", () => {
-    const realTarget = join(dir, "somewhere-else");
-    const dataDir = join(dir, ".spf", "data");
-    mkdirSync(realTarget, { recursive: true });
-    mkdirSync(join(dir, ".spf"), { recursive: true });
-    symlinkSync(realTarget, dataDir, "dir");
-    rmSync(realTarget, { recursive: true, force: true }); // now dataDir points at nothing
-    const anchor = resolveAnchor(dir);
-    resolveDataPaths(anchor, ".spf/data", ".spf/data/spf.db");
-    assert.equal(existsSync(dataDir), false);
-});
-test("resolveDataPaths: an ordinary real directory is left completely alone", () => {
-    const dataDir = join(dir, ".spf", "data");
-    mkdirSync(dataDir, { recursive: true });
-    writeFileSync(join(dataDir, "spf.db"), "not actually sqlite, just a marker");
-    const anchor = resolveAnchor(dir);
-    resolveDataPaths(anchor, ".spf/data", ".spf/data/spf.db");
-    assert.ok(existsSync(join(dataDir, "spf.db")), "a real, already-populated data_dir must never be touched");
-});
-test("resolveDataPaths: data_dir not existing yet (the ordinary first-run case) is a silent no-op", () => {
-    const anchor = resolveAnchor(dir);
-    assert.doesNotThrow(() => resolveDataPaths(anchor, ".spf/data", ".spf/data/spf.db"));
-    assert.equal(existsSync(join(dir, ".spf", "data")), false, "resolveDataPaths itself never creates the directory — only heals a broken one");
-});
-test("resolveDataPaths: a real FILE at data_dir's path (not a symlink) is left alone — not this bug", () => {
-    mkdirSync(join(dir, ".spf"), { recursive: true });
-    const dataDir = join(dir, ".spf", "data");
-    writeFileSync(dataDir, "oops, a file where a directory should be");
-    const anchor = resolveAnchor(dir);
-    resolveDataPaths(anchor, ".spf/data", ".spf/data/spf.db");
-    assert.ok(existsSync(dataDir), "only a broken SYMLINK is this function's concern, not any other kind of misconfiguration");
-    assert.equal(lstatSync(dataDir).isSymbolicLink(), false);
-});

package/dist/test/refine.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/refine.test.js

@@ -1,189 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { publish, resolveAuthoringProvider } from "../core/refine.js";
-import { refinementWellFormed } from "../core/gates.js";
-/** Only the `watch:` fields resolveAuthoringProvider actually reads — the rest of SFConfig is irrelevant to it. */
-function makeCfg(watch) {
-    return {
-        watch: {
-            issue_provider: "github",
-            code_host: "github",
-            repo: "",
-            issue_repo: "",
-            label_prefix: "spf",
-            chain: "plan-build-test",
-            base_branch: "main",
-            poll_ms: 60_000,
-            concurrency: 2,
-            jira: { base_url: "", project_key: "" },
-            refine: { enabled: false, chain: "refine", concurrency: 1 },
-            ...watch,
-        },
-    };
-}
-/** In-memory fake — exactly the seam `IssueAuthoringProvider` exists for. */
-class FakeTracker {
-    created = [];
-    links = [];
-    nextId = 1;
-    async createIssue(input) {
-        this.created.push(input);
-        const id = String(this.nextId++);
-        return { id, internal_id: `db-${id}`, title: input.title, body: input.body, labels: input.labels };
-    }
-    async linkChild(parent, child) {
-        this.links.push({ parent: parent.id, child: child.id });
-    }
-}
-// ── resolveAuthoringProvider ─────────────────────────────────────────────
-test("resolveAuthoringProvider: rejects a non-github issue_provider", () => {
-    assert.throws(() => resolveAuthoringProvider(makeCfg({ issue_provider: "jira" })), /does not support issue authoring/);
-});
-test("resolveAuthoringProvider: rejects when neither issue_repo nor repo is set", () => {
-    assert.throws(() => resolveAuthoringProvider(makeCfg({ issue_provider: "github", repo: "", issue_repo: "" })), /watch\.repo/);
-});
-test("resolveAuthoringProvider: rejects when GITHUB_TOKEN is unset", () => {
-    const before = process.env["GITHUB_TOKEN"];
-    delete process.env["GITHUB_TOKEN"];
-    try {
-        assert.throws(() => resolveAuthoringProvider(makeCfg({ issue_provider: "github", repo: "acme/widgets" })), /GITHUB_TOKEN/);
-    }
-    finally {
-        if (before !== undefined)
-            process.env["GITHUB_TOKEN"] = before;
-    }
-});
-test("resolveAuthoringProvider: issue_repo overrides repo — the github-issues-against-bitbucket-code case", async () => {
-    const before = process.env["GITHUB_TOKEN"];
-    process.env["GITHUB_TOKEN"] = "test-token";
-    const originalFetch = globalThis.fetch;
-    let capturedUrl = "";
-    globalThis.fetch = async (url) => {
-        capturedUrl = String(url);
-        return { ok: true, status: 201, json: async () => ({ id: 1, number: 1, title: "x", body: "", labels: [] }) };
-    };
-    try {
-        // repo is the BITBUCKET code repo here — issue authoring must use
-        // issue_repo (the GitHub repo), never fall back to repo, or it would
-        // try to create a GitHub issue against a Bitbucket-shaped identifier.
-        const provider = resolveAuthoringProvider(makeCfg({ issue_provider: "github", repo: "acme-workspace/widgets-code", issue_repo: "acme/widgets-issues" }));
-        await provider.createIssue({ title: "x", body: "", labels: [] });
-    }
-    finally {
-        globalThis.fetch = originalFetch;
-        if (before !== undefined)
-            process.env["GITHUB_TOKEN"] = before;
-        else
-            delete process.env["GITHUB_TOKEN"];
-    }
-    assert.match(capturedUrl, /acme\/widgets-issues/);
-    assert.doesNotMatch(capturedUrl, /widgets-code/);
-});
-function node(overrides) {
-    return { body: "", parent: "", blocked_by: [], ...overrides };
-}
-// ── publish() ────────────────────────────────────────────────────────────
-test("publish: creates a container before its children, and links them via linkChild", async () => {
-    const tracker = new FakeTracker();
-    const issues = [
-        node({ key: "S1", kind: "story", title: "Owner invites by email", parent: "F1" }),
-        node({ key: "F1", kind: "feature", title: "Team invitations" }),
-    ];
-    const created = await publish(tracker, issues, { labelPrefix: "spf" });
-    assert.deepEqual(tracker.created.map((c) => c.title), ["Team invitations", "Owner invites by email"], "the parent must be created before its child");
-    assert.deepEqual(tracker.links, [{ parent: "1", child: "2" }]);
-    assert.deepEqual(created.map((c) => ({ key: c.key, isLeaf: c.isLeaf })), [
-        { key: "F1", isLeaf: false },
-        { key: "S1", isLeaf: true },
-    ]);
-});
-test("publish: labels a leaf with its type AND spf:refined; a container gets only its type label", async () => {
-    const tracker = new FakeTracker();
-    const issues = [node({ key: "F1", kind: "feature", title: "A feature" }), node({ key: "S1", kind: "story", title: "A leaf", parent: "F1" })];
-    await publish(tracker, issues, { labelPrefix: "spf" });
-    const feature = tracker.created.find((c) => c.title === "A feature");
-    const leaf = tracker.created.find((c) => c.title === "A leaf");
-    assert.deepEqual(feature.labels, ["spf:type:feature"]);
-    assert.deepEqual(leaf.labels, ["spf:type:story", "spf:refined"]);
-});
-test("publish: creates a blocker before what it blocks, and renders a real #n reference in the body", async () => {
-    const tracker = new FakeTracker();
-    const issues = [
-        node({ key: "S2", kind: "bug", title: "Fix the expiry check", blocked_by: ["S1"] }),
-        node({ key: "S1", kind: "story", title: "Owner invites by email" }),
-    ];
-    const created = await publish(tracker, issues, { labelPrefix: "spf" });
-    const s1Id = created.find((c) => c.key === "S1").issue.id;
-    const s2 = tracker.created.find((c) => c.title === "Fix the expiry check");
-    assert.equal(created[0].key, "S1", "the blocker publishes first");
-    assert.match(s2.body, new RegExp(`## Blocked by\\n\\n- #${s1Id}`));
-});
-test("publish: a leaf with no blockers gets the 'None (can start immediately)' text", async () => {
-    const tracker = new FakeTracker();
-    const created = await publish(tracker, [node({ key: "S1", kind: "story", title: "A leaf" })], { labelPrefix: "spf" });
-    assert.match(created[0].issue.body, /## Blocked by\n\nNone \(can start immediately\)\./);
-});
-test("publish: renders '## Parent: #<id>' when a spec issue id is given, and omits it otherwise", async () => {
-    const tracker = new FakeTracker();
-    const withSpec = await publish(tracker, [node({ key: "S1", kind: "story", title: "A leaf" })], { labelPrefix: "spf", specIssueId: "42" });
-    assert.match(withSpec[0].issue.body, /## Parent\n\nDecomposed from #42\./);
-    const tracker2 = new FakeTracker();
-    const withoutSpec = await publish(tracker2, [node({ key: "S1", kind: "story", title: "A leaf" })], { labelPrefix: "spf" });
-    assert.doesNotMatch(withoutSpec[0].issue.body, /## Parent/);
-});
-// ── gates.refinementWellFormed ───────────────────────────────────────────
-function envelope(issues) {
-    return { status: "success", summary: "", artifacts: [], notes_for_next_agent: "", issues };
-}
-test("refinementWellFormed: an empty issues list fails", () => {
-    const report = refinementWellFormed(envelope([]), { repo_root: "/repo" });
-    assert.equal(report.passed, false);
-});
-test("refinementWellFormed: a well-formed feature/story tree with no blockers passes clean", () => {
-    const report = refinementWellFormed(envelope([node({ key: "F1", kind: "feature", title: "A feature" }), node({ key: "S1", kind: "story", title: "A leaf", parent: "F1" })]), { repo_root: "/repo" });
-    assert.equal(report.passed, true);
-});
-test("refinementWellFormed: a container mislabeled as a leaf kind fails", () => {
-    const report = refinementWellFormed(envelope([node({ key: "F1", kind: "story", title: "Should be a feature" }), node({ key: "S1", kind: "story", title: "A leaf", parent: "F1" })]), { repo_root: "/repo" });
-    assert.equal(report.passed, false);
-    assert.ok(report.violations.some((v) => v.includes("F1.kind")));
-});
-test("refinementWellFormed: a two-node parent cycle has no leaves AND fails the dependency-graph check", () => {
-    // A finite, ACYCLIC parent forest always has at least one leaf by
-    // construction (some node's children set is empty) — the only way to
-    // drive leafCount to zero is a cycle, which the dependency-graph check
-    // already independently rejects. This test exercises that overlap
-    // directly rather than asserting an "all containers, no leaves" shape
-    // that isn't otherwise reachable.
-    const report = refinementWellFormed(envelope([node({ key: "F1", kind: "feature", title: "A", parent: "F2" }), node({ key: "F2", kind: "feature", title: "B", parent: "F1" })]), { repo_root: "/repo" });
-    assert.equal(report.passed, false);
-    assert.ok(report.violations.some((v) => v.toLowerCase().includes("cycle")));
-    assert.ok(report.violations.some((v) => v.toLowerCase().includes("leaves")));
-});
-test("refinementWellFormed: an unresolved parent key fails", () => {
-    const report = refinementWellFormed(envelope([node({ key: "S1", kind: "story", title: "Orphaned", parent: "nonexistent" })]), {
-        repo_root: "/repo",
-    });
-    assert.equal(report.passed, false);
-    assert.ok(report.violations.some((v) => v.includes("parent")));
-});
-test("refinementWellFormed: an unresolved blocked_by key fails", () => {
-    const report = refinementWellFormed(envelope([node({ key: "S1", kind: "story", title: "A leaf", blocked_by: ["nonexistent"] })]), {
-        repo_root: "/repo",
-    });
-    assert.equal(report.passed, false);
-    assert.ok(report.violations.some((v) => v.includes("blocked_by")));
-});
-test("refinementWellFormed: a blocked_by cycle fails", () => {
-    const report = refinementWellFormed(envelope([
-        node({ key: "S1", kind: "story", title: "A", blocked_by: ["S2"] }),
-        node({ key: "S2", kind: "story", title: "B", blocked_by: ["S1"] }),
-    ]), { repo_root: "/repo" });
-    assert.equal(report.passed, false);
-    assert.ok(report.violations.some((v) => v.toLowerCase().includes("cycle")));
-});
-test("refinementWellFormed: duplicate keys fail", () => {
-    const report = refinementWellFormed(envelope([node({ key: "S1", kind: "story", title: "A" }), node({ key: "S1", kind: "bug", title: "B" })]), { repo_root: "/repo" });
-    assert.equal(report.passed, false);
-    assert.ok(report.violations.some((v) => v.includes("duplicate")));
-});

package/dist/test/repo_chains.test.d.ts

@@ -1,21 +0,0 @@
-/**
- * Repo-local chains (`.spf/chains/*.yaml`) — the loader's contract.
- *
- * Two things are under test here, and they pull in opposite directions:
- *
- *  1. A yaml chain must be INDISTINGUISHABLE from a hand-written one. It is
- *     built with the same `stepChain()` from the same step factories, so its
- *     derived `phases`/`requiredAgents`/`requiredSuites` must come out
- *     byte-identical to the equivalent built-in composition. If that ever
- *     stops being true, a repo chain has become a second run path — the
- *     thing `repo_chains.ts` exists to avoid.
- *  2. A BAD yaml file must never throw. `loadRepoChains()` runs at CLI
- *     startup for every command; one malformed file in a repo cannot be
- *     allowed to break `spf sessions` or `spf doctor`. Every failure mode
- *     below asserts `problems`, and asserts the loader RETURNED.
- *
- * Nothing here shells out to git: `RepoAnchor` is a plain data object, so
- * the tests construct one pointing at a temp directory rather than
- * initializing a repo to be discovered.
- */
-export {};