agent-sdd 1.0.3

package/dist/features/ready/adapters/outbound/NodeReadyFileSystem.js

@@ -0,0 +1,159 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { configFromJson, } from "../../../../shared/domain/Config.js";
+import { configFailure } from "../../../../shared/domain/Errors.js";
+export class NodeReadyFileSystem {
+    async config(repoRoot) {
+        const configPath = join(repoRoot, ".sdd", "config.json");
+        const text = await readConfig(configPath);
+        return configFromJson(parseConfigJson(text, configPath), configPath);
+    }
+    async resolveSpecFiles(repoRoot, patterns) {
+        return readMatched(repoRoot, patterns);
+    }
+    async resolveTestFiles(repoRoot, patterns) {
+        return readMatched(repoRoot, patterns);
+    }
+}
+async function readMatched(repoRoot, patterns) {
+    const matched = new Set();
+    for (const pattern of patterns) {
+        for (const abs of await expandGlob(repoRoot, pattern)) {
+            matched.add(abs);
+        }
+    }
+    const list = [...matched].sort();
+    const out = [];
+    for (const abs of list) {
+        const text = await readFile(abs, "utf8");
+        const rel = relative(repoRoot, abs);
+        out.push({ path: rel.split("\\").join("/"), content: text });
+    }
+    return out;
+}
+/*
+ * CST-003 / INV-004 / CST-006 — minimal glob expander, duplicated from
+ * features/lint to avoid a cross-slice import (no third-party glob library).
+ */
+async function expandGlob(repoRoot, pattern) {
+    const normalised = pattern.split("\\").join("/");
+    if (!hasGlob(normalised)) {
+        const abs = resolve(repoRoot, normalised);
+        return (await isFile(abs)) ? [abs] : [];
+    }
+    const segments = normalised.split("/");
+    const literalSegments = [];
+    let firstGlobIndex = -1;
+    for (let i = 0; i < segments.length; i++) {
+        if (hasGlob(segments[i])) {
+            firstGlobIndex = i;
+            break;
+        }
+        literalSegments.push(segments[i]);
+    }
+    const baseDir = resolve(repoRoot, ...literalSegments);
+    const remaining = segments.slice(firstGlobIndex);
+    const out = [];
+    await walkAndMatch(baseDir, remaining, out);
+    return out;
+}
+async function walkAndMatch(dir, remaining, acc) {
+    if (remaining.length === 0) {
+        return;
+    }
+    const head = remaining[0];
+    const rest = remaining.slice(1);
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    if (head === "**") {
+        if (rest.length === 0) {
+            for (const entry of entries) {
+                const abs = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await walkAndMatch(abs, ["**"], acc);
+                }
+                else if (entry.isFile()) {
+                    acc.push(abs);
+                }
+            }
+            return;
+        }
+        for (const entry of entries) {
+            const abs = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walkAndMatch(abs, remaining, acc);
+            }
+        }
+        await walkAndMatch(dir, rest, acc);
+        return;
+    }
+    for (const entry of entries) {
+        if (!matchSegment(head, entry.name)) {
+            continue;
+        }
+        const abs = join(dir, entry.name);
+        if (rest.length === 0) {
+            if (entry.isFile()) {
+                acc.push(abs);
+            }
+            continue;
+        }
+        if (entry.isDirectory()) {
+            await walkAndMatch(abs, rest, acc);
+        }
+    }
+}
+function matchSegment(pattern, name) {
+    if (!hasGlob(pattern)) {
+        return pattern === name;
+    }
+    const re = new RegExp(`^${pattern
+        .split("")
+        .map((c) => {
+        if (c === "*") {
+            return "[^/]*";
+        }
+        if (c === "?") {
+            return "[^/]";
+        }
+        return c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    })
+        .join("")}$`);
+    return re.test(name);
+}
+function hasGlob(value) {
+    return /[*?[\]]/.test(value);
+}
+async function isFile(abs) {
+    try {
+        const s = await stat(abs);
+        return s.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readConfig(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        throw configFailure("config-missing", ".sdd/config.json is missing or unreadable", errorMessage(error), path);
+    }
+}
+function parseConfigJson(text, path) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw configFailure("config-invalid", ".sdd/config.json is not valid JSON", errorMessage(error), path);
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/features/ready/application/RunReady.d.ts

@@ -0,0 +1,16 @@
+import { type Diagnostic, type LintReport } from "../../../shared/domain/LintReport.js";
+import { TOKEN_MECHANISM } from "../../../shared/domain/Token.js";
+import type { ReadyInput } from "../domain/ReadyInput.js";
+import { type ReadyEnvelope, type ReadyError, type ReadyViolation } from "../domain/ReadyViolation.js";
+import type { ReadyConfigPort } from "../ports/outbound/ReadyConfigPort.js";
+import type { ReadyFileReader } from "../ports/outbound/ReadyFileReader.js";
+import type { ReadyGitPort } from "../ports/outbound/ReadyGitPort.js";
+export type { ReadyEnvelope, ReadyError, ReadyViolation };
+export interface RunReadyPorts {
+    config: ReadyConfigPort;
+    files: ReadyFileReader;
+    git: ReadyGitPort;
+}
+export declare function runReady(cwd: string, input: ReadyInput, ports: RunReadyPorts): Promise<ReadyEnvelope>;
+export declare function appendLintDiagnostic(report: LintReport, d: Diagnostic): LintReport;
+export { TOKEN_MECHANISM };