@use-the-fork/spindle 0.0.0-stage → 0.0.1

package/build/SubagentDrivenDevelopment/Persistence/AssignmentSchema.js

@@ -0,0 +1,155 @@
+import { isAbsolute } from "node:path";
+import { isCheckRecord } from "./CheckSchema.js";
+import { isReviewAssignment } from "./ReviewSchema.js";
+import { Records } from "../../Support/Records.js";
+const isRecord = Records.isRecord;
+export function isImplementationAssignment(value) {
+    if (!isRecord(value) ||
+        typeof value.id !== "string" ||
+        !value.id.trim() ||
+        value.role !== "implementation" ||
+        !["implement", "correct"].includes(String(value.action)) ||
+        typeof value.controller !== "string" ||
+        !value.controller.trim() ||
+        typeof value.report !== "string" ||
+        !isAbsolute(value.report) ||
+        typeof value.requestedAt !== "string" ||
+        !Number.isFinite(Date.parse(value.requestedAt)) ||
+        !["pending", "submitted", "unavailable"].includes(String(value.status)) ||
+        !Array.isArray(value.handoffs) ||
+        !value.handoffs.every((handoff) => isRecord(handoff) &&
+            typeof handoff.at === "string" &&
+            Number.isFinite(Date.parse(handoff.at)) &&
+            typeof handoff.from === "string" &&
+            handoff.from.trim() &&
+            typeof handoff.to === "string" &&
+            handoff.to.trim() &&
+            handoff.confirmedStopped === true)) {
+        return false;
+    }
+    if (value.action === "correct") {
+        if (!Number.isSafeInteger(value.attempt) ||
+            Number(value.attempt) < 1 ||
+            !Array.isArray(value.findingIds) ||
+            !value.findingIds.every((id) => typeof id === "string" && /^F-\d{4,}$/.test(id)) ||
+            new Set(value.findingIds).size !== value.findingIds.length ||
+            (value.findingIds.length === 0 &&
+                (typeof value.checkFailure !== "string" || !value.checkFailure.trim())) ||
+            typeof value.objective !== "string" ||
+            !value.objective.trim()) {
+            return false;
+        }
+    }
+    else if (Object.hasOwn(value, "attempt") ||
+        Object.hasOwn(value, "findingIds") ||
+        Object.hasOwn(value, "checkFailure") ||
+        Object.hasOwn(value, "objective")) {
+        return false;
+    }
+    if (value.status === "submitted") {
+        return (typeof value.reportSha256 === "string" &&
+            /^[0-9a-f]{64}$/i.test(value.reportSha256) &&
+            typeof value.submittedAt === "string" &&
+            Number.isFinite(Date.parse(value.submittedAt)) &&
+            typeof value.submittedBy === "string" &&
+            !!value.submittedBy.trim());
+    }
+    if (value.status === "unavailable") {
+        return typeof value.unavailableDetails === "string" && !!value.unavailableDetails.trim();
+    }
+    return true;
+}
+export function isCorrectionAttempt(value) {
+    if (!isRecord(value) ||
+        !Number.isSafeInteger(value.number) ||
+        Number(value.number) < 1 ||
+        !Array.isArray(value.findingIds) ||
+        !value.findingIds.every((finding) => typeof finding === "string" && /^F-\d{4,}$/.test(finding)) ||
+        new Set(value.findingIds).size !== value.findingIds.length ||
+        (value.findingIds.length === 0 &&
+            (typeof value.checkFailure !== "string" || !value.checkFailure.trim())) ||
+        typeof value.objective !== "string" ||
+        !value.objective.trim() ||
+        typeof value.startedAt !== "string" ||
+        !Number.isFinite(Date.parse(value.startedAt)) ||
+        typeof value.startedBy !== "string" ||
+        !value.startedBy.trim() ||
+        typeof value.assignmentId !== "string" ||
+        !value.assignmentId.trim() ||
+        !isImplementationAssignment(value.assignment) ||
+        value.assignment.id !== value.assignmentId ||
+        value.assignment.action !== "correct" ||
+        value.assignment.attempt !== value.number ||
+        (Object.hasOwn(value, "priorAssignment") &&
+            !isImplementationAssignment(value.priorAssignment)) ||
+        (Object.hasOwn(value, "checks") &&
+            (!Array.isArray(value.checks) || !value.checks.every(isCheckRecord))) ||
+        (Object.hasOwn(value, "reviewAssignments") &&
+            (!Array.isArray(value.reviewAssignments) ||
+                !value.reviewAssignments.every(isReviewAssignment)))) {
+        return false;
+    }
+    if (Object.hasOwn(value, "progressAssessment")) {
+        const assessment = value.progressAssessment;
+        if (!isRecord(assessment) ||
+            assessment.decision !== "continue" ||
+            assessment.result !== "productive" ||
+            typeof assessment.details !== "string" ||
+            !assessment.details.trim() ||
+            typeof assessment.recordedAt !== "string" ||
+            !Number.isFinite(Date.parse(assessment.recordedAt)) ||
+            typeof assessment.recordedBy !== "string" ||
+            !assessment.recordedBy.trim()) {
+            return false;
+        }
+    }
+    if (Object.hasOwn(value, "outcome")) {
+        const outcome = value.outcome;
+        if (!isRecord(outcome) ||
+            !["productive", "unproductive"].includes(String(outcome.result)) ||
+            typeof outcome.details !== "string" ||
+            !outcome.details.trim() ||
+            typeof outcome.recordedAt !== "string" ||
+            !Number.isFinite(Date.parse(outcome.recordedAt)) ||
+            typeof outcome.recordedBy !== "string" ||
+            !outcome.recordedBy.trim() ||
+            (Object.hasOwn(outcome, "snapshot") &&
+                (typeof outcome.snapshot !== "string" || !/^[0-9a-f]{64}$/i.test(outcome.snapshot)))) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isCorrectionAdjudication(value) {
+    if (isRecord(value) &&
+        ["pending", "resolved"].includes(String(value.status)) &&
+        typeof value.reason === "string" &&
+        !!value.reason.trim() &&
+        typeof value.details === "string" &&
+        !!value.details.trim() &&
+        typeof value.recordedAt === "string" &&
+        Number.isFinite(Date.parse(value.recordedAt)) &&
+        typeof value.recordedBy === "string" &&
+        !!value.recordedBy.trim()) {
+        return value.status === "pending"
+            ? !Object.hasOwn(value, "resolution")
+            : isRecord(value.resolution) &&
+                typeof value.resolution.details === "string" &&
+                !!value.resolution.details.trim() &&
+                typeof value.resolution.recordedAt === "string" &&
+                Number.isFinite(Date.parse(value.resolution.recordedAt)) &&
+                typeof value.resolution.recordedBy === "string" &&
+                !!value.resolution.recordedBy.trim();
+    }
+    return false;
+}
+export function hasMatchingCorrectionAttempt(ticket) {
+    const assignment = ticket.assignment;
+    if (!isImplementationAssignment(assignment) || assignment.action !== "correct")
+        return true;
+    const attempts = ticket.correctionAttempts;
+    return (Array.isArray(attempts) &&
+        attempts.some((attempt) => isCorrectionAttempt(attempt) &&
+            attempt.number === assignment.attempt &&
+            attempt.assignmentId === assignment.id));
+}

package/build/SubagentDrivenDevelopment/Persistence/CheckSchema.js

@@ -0,0 +1,71 @@
+import { isAbsolute } from "node:path";
+import { Records } from "../../Support/Records.js";
+const isRecord = Records.isRecord;
+export function isCheckRequirement(value) {
+    if (!isRecord(value) ||
+        typeof value.command !== "string" ||
+        !value.command.trim() ||
+        typeof value.addedAt !== "string" ||
+        !Number.isFinite(Date.parse(value.addedAt)) ||
+        typeof value.addedBy !== "string" ||
+        !value.addedBy.trim()) {
+        return false;
+    }
+    const removed = Object.hasOwn(value, "removedAt");
+    return (!removed ||
+        (typeof value.removedAt === "string" &&
+            Number.isFinite(Date.parse(value.removedAt)) &&
+            typeof value.removedBy === "string" &&
+            !!value.removedBy.trim() &&
+            typeof value.removalDetails === "string" &&
+            !!value.removalDetails.trim()));
+}
+export function isCheckRecord(value) {
+    if (isRecord(value) &&
+        typeof value.command === "string" &&
+        !!value.command.trim() &&
+        ["passed", "failed", "unavailable"].includes(String(value.result)) &&
+        typeof value.author === "string" &&
+        !!value.author.trim() &&
+        typeof value.snapshot === "string" &&
+        /^[0-9a-f]{64}$/i.test(value.snapshot) &&
+        typeof value.codeSnapshot === "string" &&
+        /^[0-9a-f]{64}$/i.test(value.codeSnapshot) &&
+        typeof value.requirementsSnapshot === "string" &&
+        /^[0-9a-f]{64}$/i.test(value.requirementsSnapshot) &&
+        typeof value.headSha === "string" &&
+        /^[0-9a-f]{40,64}$/i.test(value.headSha) &&
+        typeof value.recordedAt === "string" &&
+        Number.isFinite(Date.parse(value.recordedAt)) &&
+        (value.result === "passed" || (typeof value.details === "string" && !!value.details.trim()))) {
+        const hasScope = Object.hasOwn(value, "coveredPaths") || Object.hasOwn(value, "coverageSnapshot");
+        return (!hasScope ||
+            (Array.isArray(value.coveredPaths) &&
+                value.coveredPaths.length > 0 &&
+                value.coveredPaths.every(isSafeCoveragePath) &&
+                new Set(value.coveredPaths).size === value.coveredPaths.length &&
+                typeof value.coverageSnapshot === "string" &&
+                /^[0-9a-f]{64}$/i.test(value.coverageSnapshot)));
+    }
+    return false;
+}
+export function isCheckGateInvalidation(value) {
+    return (isRecord(value) &&
+        typeof value.at === "string" &&
+        Number.isFinite(Date.parse(value.at)) &&
+        typeof value.author === "string" &&
+        !!value.author.trim() &&
+        typeof value.command === "string" &&
+        !!value.command.trim() &&
+        ["accepted", "integrated"].includes(String(value.from)) &&
+        value.to === "reviewing");
+}
+export function isSafeCoveragePath(value) {
+    return (typeof value === "string" &&
+        !!value &&
+        !isAbsolute(value) &&
+        !value.includes("\\") &&
+        value.split("/").every((segment) => !!segment && segment !== "." && segment !== "..") &&
+        value !== ".scratch" &&
+        !value.startsWith(".scratch/"));
+}

package/build/SubagentDrivenDevelopment/Persistence/FeatureWorkspace.js

@@ -0,0 +1,76 @@
+import { readFileSync, readdirSync, realpathSync } from "node:fs";
+import { join, relative } from "node:path";
+import { Service } from "../../Foundation/Service.js";
+import { FEATURE_DIRECTORY, HISTORICAL_DATE_DIRECTORY, } from "../Models/Workflow.js";
+import { assertRealDirectory, lstatIfPresent, isPathInside, } from "./FileSystem.js";
+export class FeatureWorkspace extends Service {
+    ledgerRepository;
+    pathSafety;
+    constructor(app, ledgerRepository, pathSafety) {
+        super(app);
+        this.ledgerRepository = ledgerRepository;
+        this.pathSafety = pathSafety;
+    }
+    statusFromPaths(root, specPath, relativeSpec, segments) {
+        const scratch = join(root, ".scratch");
+        const workspace = join(scratch, segments[1]);
+        const ledgerPath = join(workspace, "sdd.json");
+        assertRealDirectory(scratch, ".scratch");
+        assertRealDirectory(workspace, "Feature workspace");
+        for (const directory of ["tickets", "reports"]) {
+            assertRealDirectory(join(workspace, directory), `Feature ${directory} directory`);
+        }
+        const specEntry = lstatIfPresent(specPath);
+        if (!specEntry?.isFile())
+            throw new Error("Feature spec must be a regular file.");
+        const ledgerEntry = lstatIfPresent(ledgerPath);
+        if (!ledgerEntry?.isFile())
+            throw new Error("Feature ledger must be a regular file.");
+        if (!isPathInside(root, realpathSync(specPath)) ||
+            !isPathInside(root, realpathSync(ledgerPath))) {
+            throw new Error("Feature files must remain inside this checkout.");
+        }
+        for (const path of [relativeSpec, relative(root, ledgerPath)]) {
+            if (this.pathSafety.isIgnored(root, path))
+                throw new Error(`Feature path is ignored: ${path}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(ledgerPath, "utf8"));
+        }
+        catch (error) {
+            throw new Error(`Feature ledger is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const state = this.ledgerRepository.validateLedger(parsed, segments[1]);
+        const feature = segments[1];
+        return {
+            feature,
+            workspace,
+            spec: specPath,
+            ledger: ledgerPath,
+            state,
+        };
+    }
+    nextFeatureId(scratch) {
+        let highest = 0n;
+        for (const entry of readdirSync(scratch, { withFileTypes: true })) {
+            if (!entry.isDirectory() || HISTORICAL_DATE_DIRECTORY.test(entry.name))
+                continue;
+            const match = FEATURE_DIRECTORY.exec(entry.name);
+            if (!match)
+                continue;
+            const id = BigInt(match[1]);
+            if (id > highest)
+                highest = id;
+        }
+        return String(highest + 1n).padStart(4, "0");
+    }
+    rejectAbandonedStaging(scratch) {
+        const abandoned = readdirSync(scratch, { withFileTypes: true })
+            .filter((entry) => entry.name.startsWith(".sdd-create-"))
+            .map((entry) => join(scratch, entry.name));
+        if (abandoned.length > 0) {
+            throw new Error(`Incomplete feature creation staging content was preserved at ${abandoned.join(", ")}. Inspect and remove it before retrying.`);
+        }
+    }
+}

package/build/SubagentDrivenDevelopment/Persistence/FileSystem.js

@@ -0,0 +1,28 @@
+import { lstatSync } from "node:fs";
+import { isAbsolute, relative, sep } from "node:path";
+export function assertRealDirectory(path, label) {
+    const entry = lstatSync(path, { throwIfNoEntry: false });
+    if (entry && !entry.isDirectory()) {
+        throw new Error(`${label} must be a real directory, not a file or symlink.`);
+    }
+}
+export function lstatIfPresent(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function waitBriefly() {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+}
+export function isPathInside(parent, child) {
+    const relativePath = relative(parent, child);
+    return (relativePath === "" ||
+        (!isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep}`)));
+}
+export const LOCK_TIMEOUT_MS = 15_000;

package/build/SubagentDrivenDevelopment/Persistence/FindingSchema.js

@@ -0,0 +1,81 @@
+import { isAbsolute } from "node:path";
+import { Records } from "../../Support/Records.js";
+const isRecord = Records.isRecord;
+export function isReviewFinding(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        /^F-\d{4,}$/.test(value.id) &&
+        (!Object.hasOwn(value, "relatedTicket") ||
+            (typeof value.relatedTicket === "string" && /^T-\d{4,}$/.test(value.relatedTicket))) &&
+        ["high", "medium", "low"].includes(String(value.severity)) &&
+        typeof value.blocking === "boolean" &&
+        ["open", "confirmed", "fixed", "dismissed", "deferred"].includes(String(value.status)) &&
+        typeof value.summary === "string" &&
+        !!value.summary.trim() &&
+        typeof value.details === "string" &&
+        !!value.details.trim() &&
+        typeof value.author === "string" &&
+        !!value.author.trim() &&
+        typeof value.createdAt === "string" &&
+        Number.isFinite(Date.parse(value.createdAt)) &&
+        Array.isArray(value.provenance) &&
+        value.provenance.length > 0 &&
+        value.provenance.every((source) => isRecord(source) &&
+            typeof source.report === "string" &&
+            isAbsolute(source.report) &&
+            typeof source.snapshot === "string" &&
+            /^[0-9a-f]{64}$/i.test(source.snapshot) &&
+            typeof source.author === "string" &&
+            !!source.author.trim() &&
+            typeof source.summary === "string" &&
+            !!source.summary.trim() &&
+            typeof source.details === "string" &&
+            !!source.details.trim()) &&
+        Array.isArray(value.history) &&
+        value.history.every((entry) => isRecord(entry) &&
+            typeof entry.at === "string" &&
+            Number.isFinite(Date.parse(entry.at)) &&
+            typeof entry.author === "string" &&
+            !!entry.author.trim() &&
+            typeof entry.action === "string" &&
+            !!entry.action.trim() &&
+            typeof entry.details === "string" &&
+            !!entry.details.trim()) &&
+        (value.status !== "dismissed" ||
+            (typeof value.rulingDetails === "string" && !!value.rulingDetails.trim())) &&
+        (value.status !== "deferred" ||
+            (typeof value.rulingDetails === "string" &&
+                !!value.rulingDetails.trim() &&
+                typeof value.followUp === "string" &&
+                !!value.followUp.trim())) &&
+        (!Object.hasOwn(value, "requirementsDecision") ||
+            (typeof value.requirementsDecision === "string" &&
+                /^R-\d{4,}$/.test(value.requirementsDecision))) &&
+        (value.status !== "fixed" ||
+            (isRecord(value.verification) &&
+                typeof value.verification.snapshot === "string" &&
+                /^[0-9a-f]{64}$/i.test(value.verification.snapshot) &&
+                Array.isArray(value.verification.checkCommands) &&
+                value.verification.checkCommands.length > 0 &&
+                value.verification.checkCommands.every((command) => typeof command === "string" && !!command.trim()) &&
+                typeof value.verification.verifiedAt === "string" &&
+                Number.isFinite(Date.parse(value.verification.verifiedAt)) &&
+                typeof value.verification.verifiedBy === "string" &&
+                !!value.verification.verifiedBy.trim())));
+}
+export function isRequirementsDecision(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        /^R-\d{4,}$/.test(value.id) &&
+        typeof value.finding === "string" &&
+        /^F-\d{4,}$/.test(value.finding) &&
+        ["approved", "rejected"].includes(String(value.status)) &&
+        typeof value.details === "string" &&
+        !!value.details.trim() &&
+        typeof value.author === "string" &&
+        !!value.author.trim() &&
+        typeof value.requirementsSnapshot === "string" &&
+        /^[0-9a-f]{64}$/i.test(value.requirementsSnapshot) &&
+        typeof value.recordedAt === "string" &&
+        Number.isFinite(Date.parse(value.recordedAt)));
+}