@multileaf/ai-workflow 0.1.0

package/dist/recommendations.js

@@ -0,0 +1,63 @@
+const CATALOG = [
+    {
+        id: "tdd-development",
+        provider: "multileaf",
+        rationale: "The project uses automated tests and should preserve test-first development.",
+        matches: (profile) => profile.testing
+            ? { evidence: [`testing:${profile.testing.name}`], confidence: 1 }
+            : undefined,
+    },
+    {
+        id: "typescript-quality",
+        provider: "multileaf",
+        rationale: "TypeScript is present and benefits from strict, maintainable code-quality rules.",
+        matches: (profile) => profile.runtime.languages.includes("typescript")
+            ? { evidence: ["language:typescript"], confidence: 1 }
+            : undefined,
+    },
+    {
+        id: "vitest-testing",
+        provider: "multileaf",
+        rationale: "Vitest is configured and can be integrated into the verification workflow.",
+        matches: (profile) => profile.testing?.name === "vitest"
+            ? { evidence: ["testing:vitest"], confidence: 1 }
+            : undefined,
+    },
+    {
+        id: "react-best-practices",
+        provider: "vercel-skills",
+        rationale: "React is detected; framework-specific guidance can improve component design and performance.",
+        matches: (profile) => profile.frameworks.includes("react")
+            ? { evidence: ["framework:react"], confidence: 1 }
+            : undefined,
+    },
+    {
+        id: "nextjs-development",
+        provider: "multileaf",
+        rationale: "Next.js is detected; project-specific conventions can guide routing and rendering decisions.",
+        matches: (profile) => profile.frameworks.includes("nextjs")
+            ? { evidence: ["framework:nextjs"], confidence: 1 }
+            : undefined,
+    },
+];
+export function recommendCapabilities(profile) {
+    return CATALOG.flatMap((capability) => {
+        const match = capability.matches(profile);
+        return match
+            ? [
+                {
+                    id: capability.id,
+                    provider: capability.provider,
+                    confidence: match.confidence,
+                    rationale: capability.rationale,
+                    evidence: match.evidence,
+                    permissions: capability.permissions ?? [],
+                    conflicts: [],
+                },
+            ]
+            : [];
+    });
+}
+export function serializeRecommendations(items, selected = []) {
+    return `schema: 1\nrecommendations:\n${items.map((item) => `  - id: ${item.id}\n    provider: ${item.provider}\n    confidence: ${item.confidence}\n    selected: ${selected.includes(item.id)}\n    evidence: [${item.evidence.map((evidence) => `"${evidence}"`).join(", ")}]\n    rationale: ${item.rationale}`).join("\n")}\n`;
+}

package/dist/registry.d.ts

@@ -0,0 +1,11 @@
+export type RegistryPackage = {
+    id: string;
+    version: string;
+    description: string;
+    provider: "local" | "git" | "vercel-skills" | "private-registry";
+    source: string;
+    permissions: string[];
+};
+export declare const CURATED_REGISTRY: readonly RegistryPackage[];
+export declare function searchRegistry(query?: string): RegistryPackage[];
+export declare function serializeRegistry(packages: readonly RegistryPackage[]): string;

package/dist/registry.js

@@ -0,0 +1,27 @@
+export const CURATED_REGISTRY = [
+    {
+        id: "multileaf/aiw-self-hosting",
+        version: "0.1.0",
+        description: "Core skills and policies for developing with AI Workflow.",
+        provider: "local",
+        source: "./resources",
+        permissions: [],
+    },
+    {
+        id: "vercel/react-best-practices",
+        version: "latest",
+        description: "React and Next.js performance guidance from Vercel.",
+        provider: "vercel-skills",
+        source: "vercel-labs/agent-skills@vercel-react-best-practices",
+        permissions: ["network:external"],
+    },
+];
+export function searchRegistry(query = "") {
+    const normalized = query.trim().toLowerCase();
+    return CURATED_REGISTRY.filter((pkg) => [pkg.id, pkg.description, pkg.provider].some((field) => field.toLowerCase().includes(normalized))).map((pkg) => ({ ...pkg, permissions: [...pkg.permissions] }));
+}
+export function serializeRegistry(packages) {
+    return packages
+        .map((pkg) => `${pkg.id}@${pkg.version} [${pkg.provider}] permissions: ${pkg.permissions.join(",") || "none"} - ${pkg.description}`)
+        .join("\n");
+}

package/dist/scanner.d.ts

@@ -0,0 +1,9 @@
+export type ProjectEvidence = {
+    fact: string;
+    source: string;
+};
+export type ProjectScan = {
+    files: string[];
+    evidence: ProjectEvidence[];
+};
+export declare function scanProject(root: string): Promise<ProjectScan>;

package/dist/scanner.js

@@ -0,0 +1,83 @@
+import { lstat, readFile, readdir } from "node:fs/promises";
+import { basename, relative, resolve } from "node:path";
+const DEFAULT_IGNORES = new Set([
+    ".git",
+    "node_modules",
+    ".aiw",
+    ".agents",
+    ".claude",
+    ".cursor",
+    "dist",
+    "coverage",
+]);
+const SENSITIVE_NAMES = /^(\.env(?:\..*)?|.*\.(pem|key|p12|pfx|secret))$/i;
+function matchesIgnore(path, patterns) {
+    const name = basename(path);
+    return patterns.some((pattern) => {
+        const normalized = pattern.replace(/^\//, "").replace(/\/$/, "");
+        if (normalized.includes("*")) {
+            const expression = new RegExp(`^${normalized.split("*").map(escapeRegExp).join(".*")}$`);
+            return expression.test(path) || expression.test(name);
+        }
+        return path === normalized || path.startsWith(`${normalized}/`) || name === normalized;
+    });
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function ignoredPatterns(root) {
+    try {
+        const content = await readFile(resolve(root, ".gitignore"), "utf8");
+        return content
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith("#"));
+    }
+    catch {
+        return [];
+    }
+}
+async function collect(root, current, patterns, files) {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const absolute = resolve(current, entry.name);
+        const relativePath = relative(root, absolute).split("\\").join("/");
+        if (DEFAULT_IGNORES.has(entry.name) ||
+            SENSITIVE_NAMES.test(entry.name) ||
+            matchesIgnore(relativePath, patterns))
+            continue;
+        if (entry.isSymbolicLink()) {
+            const link = await lstat(absolute);
+            if (link.isSymbolicLink())
+                continue;
+        }
+        if (entry.isDirectory())
+            await collect(root, absolute, patterns, files);
+        else if (entry.isFile())
+            files.push(relativePath);
+    }
+}
+function detectEvidence(files) {
+    const evidence = [];
+    for (const file of files) {
+        if (/\.(ts|tsx)$/.test(file))
+            evidence.push({ fact: "language.typescript", source: file });
+        if (/\.(js|jsx|mjs|cjs)$/.test(file))
+            evidence.push({ fact: "language.javascript", source: file });
+        if (basename(file).startsWith("eslint.config") || file === ".eslintrc.json")
+            evidence.push({ fact: "tool.eslint", source: file });
+        if (file === "package.json")
+            evidence.push({ fact: "package-manager.npm", source: file });
+        if (file === "pnpm-lock.yaml")
+            evidence.push({ fact: "package-manager.pnpm", source: file });
+        if (file === "yarn.lock")
+            evidence.push({ fact: "package-manager.yarn", source: file });
+    }
+    return evidence;
+}
+export async function scanProject(root) {
+    const projectRoot = resolve(root);
+    const files = [];
+    await collect(projectRoot, projectRoot, await ignoredPatterns(projectRoot), files);
+    return { files, evidence: detectEvidence(files) };
+}

package/dist/selection.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityRecommendation } from "./recommendations.js";
+export type Answer = (question: string) => Promise<string>;
+export declare function selectRecommendations(items: CapabilityRecommendation[], answer: Answer, selectedIds?: string[]): Promise<string[]>;

package/dist/selection.js

@@ -0,0 +1,11 @@
+export async function selectRecommendations(items, answer, selectedIds) {
+    if (selectedIds)
+        return selectedIds.filter((id) => items.some((item) => item.id === id));
+    const selected = [];
+    for (const item of items) {
+        const response = (await answer(`Install ${item.id}? [Y/n] `)).trim().toLowerCase();
+        if (response === "" || response === "y" || response === "yes")
+            selected.push(item.id);
+    }
+    return selected;
+}

package/dist/self-validation.d.ts

@@ -0,0 +1,9 @@
+export type SelfValidationEvidence = {
+    ticket: string;
+    command: string;
+    exitCode: number;
+    requiredState: string[];
+    generatedArtifacts: string[];
+};
+export declare function validateTicketId(ticket: string): void;
+export declare function serializeSelfValidationEvidence(evidence: SelfValidationEvidence): string;

package/dist/self-validation.js

@@ -0,0 +1,9 @@
+export function validateTicketId(ticket) {
+    if (!/^[A-Z]+-\d{3}$/.test(ticket))
+        throw new Error("Self-validation ticket must match TYPE-000, for example FND-009.");
+}
+export function serializeSelfValidationEvidence(evidence) {
+    const state = [...evidence.requiredState].sort();
+    const artifacts = [...evidence.generatedArtifacts].sort();
+    return `schema: 1\nticket: ${evidence.ticket}\ncommand: ${evidence.command}\nexit_code: ${evidence.exitCode}\nrequired_state:\n${state.map((path) => `  - ${path}`).join("\n")}\ngenerated_artifacts:\n${artifacts.length ? artifacts.map((path) => `  - ${path}`).join("\n") : "  - none"}\nresult: ${evidence.exitCode === 0 ? "pass" : "fail"}\n`;
+}

package/dist/services.d.ts

@@ -0,0 +1,42 @@
+import type { ProjectProfile } from "./profile.js";
+import type { ProjectScan } from "./scanner.js";
+import type { CapabilityRecommendation } from "./recommendations.js";
+import type { Interpreter } from "./interpreter.js";
+import type { CommandExecutor } from "./vercel-skills.js";
+import type { CommandResult, FileSystem } from "./types.js";
+import type { PackageSourceLoader } from "./providers.js";
+import type { PrivateRegistryClient } from "./team-configuration.js";
+import type { PolicyTracking } from "./policy-gate.js";
+import type { TelemetryClient } from "./telemetry.js";
+import type { DashboardHandle } from "./dashboard.js";
+import type { AgentOrchestrator } from "./orchestration.js";
+export interface ProjectScanner {
+    scan(root: string): Promise<ProjectScan>;
+}
+export interface ProfileService {
+    profile(root: string): Promise<ProjectProfile>;
+}
+export interface RecommendationService {
+    recommend(profile: ProjectProfile): CapabilityRecommendation[];
+}
+export interface WorkflowDependencies {
+    scanner?: ProjectScanner;
+    profiler?: ProfileService;
+    recommender?: RecommendationService;
+    interpreter?: Interpreter;
+    externalSkills?: CommandExecutor;
+    packageSources?: PackageSourceLoader;
+    selfValidation?: CommandExecutor;
+    privateRegistries?: PrivateRegistryClient;
+    environment?: Readonly<Record<string, string | undefined>>;
+    policyTracking?: PolicyTracking;
+    telemetry?: TelemetryClient;
+    dashboard?: {
+        start(root: string, port: number): Promise<DashboardHandle>;
+    };
+    orchestrator?: AgentOrchestrator;
+}
+export interface WorkflowService {
+    execute(args: string[], root: string, fs: FileSystem): Promise<CommandResult>;
+}
+export type ServiceFactory<T> = (dependencies: WorkflowDependencies) => T;

package/dist/services.js

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

package/dist/team-configuration.d.ts

@@ -0,0 +1,23 @@
+export type TeamPreset = {
+    schema: 1;
+    name: string;
+    packages: string[];
+    registries: string[];
+};
+export type PrivateRegistry = {
+    name: string;
+    url: string;
+    tokenEnv: string;
+};
+export type PrivateRegistryConfiguration = {
+    schema: 1;
+    registries: PrivateRegistry[];
+};
+export interface PrivateRegistryClient {
+    search(registry: PrivateRegistry, query: string, token: string): Promise<unknown>;
+}
+export declare const fetchPrivateRegistryClient: PrivateRegistryClient;
+export declare function parseTeamPreset(content: string): TeamPreset;
+export declare function serializeTeamPreset(preset: TeamPreset): string;
+export declare function parsePrivateRegistries(content: string): PrivateRegistryConfiguration;
+export declare function serializePrivateRegistries(configuration: PrivateRegistryConfiguration): string;

package/dist/team-configuration.js

@@ -0,0 +1,104 @@
+export const fetchPrivateRegistryClient = {
+    async search(registry, query, token) {
+        const endpoint = new URL(registry.url);
+        endpoint.searchParams.set("q", query);
+        const response = await fetch(endpoint, {
+            headers: { authorization: `Bearer ${token}`, accept: "application/json" },
+        });
+        if (!response.ok)
+            throw new Error(`Private registry ${registry.name} returned HTTP ${response.status}.`);
+        return response.json();
+    },
+};
+export function parseTeamPreset(content) {
+    assertSchema(content, "Team preset");
+    const name = scalar(content, "name");
+    if (!name)
+        throw new Error("Team preset name is required.");
+    return {
+        schema: 1,
+        name,
+        packages: normalizedList(content, "packages", "Team preset"),
+        registries: normalizedList(content, "registries", "Team preset"),
+    };
+}
+export function serializeTeamPreset(preset) {
+    return `schema: 1\nname: ${preset.name}\npackages: [${preset.packages.join(", ")}]\nregistries: [${preset.registries.join(", ")}]\n`;
+}
+export function parsePrivateRegistries(content) {
+    assertSchema(content, "Private registry configuration");
+    const lines = content.split(/\r?\n/).filter((line) => line.trim());
+    const entryLines = lines.slice(2);
+    if (!/^schema:[ \t]*1[ \t]*$/.test(lines[0] ?? "") || !/^registries:[ \t]*$/.test(lines[1] ?? ""))
+        throw new Error("Private registry configuration contains unsupported or malformed fields.");
+    if (!entryLines.every((line) => /^[ \t]+-[ \t]+\{[^\r\n]+\}[ \t]*$/.test(line)))
+        throw new Error("Private registry configuration contains unsupported or malformed fields.");
+    const entries = entryLines.map((line) => parseRegistryEntry(line.slice(line.indexOf("{") + 1, line.lastIndexOf("}"))));
+    if (!entries.length)
+        throw new Error("Private registry configuration registries must not be empty.");
+    const names = new Set();
+    for (const registry of entries) {
+        if (names.has(registry.name))
+            throw new Error(`Duplicate private registry: ${registry.name}`);
+        names.add(registry.name);
+    }
+    return { schema: 1, registries: entries.sort((a, b) => a.name.localeCompare(b.name)) };
+}
+export function serializePrivateRegistries(configuration) {
+    return `schema: 1\nregistries:\n${configuration.registries
+        .map(({ name, url, tokenEnv }) => `  - { name: ${name}, url: ${url}, token_env: ${tokenEnv} }`)
+        .join("\n")}\n`;
+}
+function parseRegistryEntry(content) {
+    const pairs = content.split(",").map((part) => {
+        const separator = part.indexOf(":");
+        if (separator < 1)
+            throw new Error("Private registry entries must use key: value fields.");
+        return [part.slice(0, separator).trim(), part.slice(separator + 1).trim()];
+    });
+    if (new Set(pairs.map(([key]) => key)).size !== pairs.length)
+        throw new Error("Private registry entries must not contain duplicate fields.");
+    const fields = new Map(pairs);
+    const name = fields.get("name") ?? "";
+    const url = fields.get("url") ?? "";
+    const tokenEnv = fields.get("token_env") ?? "";
+    if (!name || !url || !tokenEnv)
+        throw new Error("Private registry entries require name, url, and token_env.");
+    if (fields.has("token") || fields.has("password") || fields.size !== 3)
+        throw new Error("Private registry credentials must use token_env; secret values are forbidden.");
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(name))
+        throw new Error("Invalid private registry name.");
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error("Invalid private registry URL.");
+    }
+    if (parsed.protocol !== "https:")
+        throw new Error("Private registry URLs must use HTTPS.");
+    if (parsed.username || parsed.password || parsed.search || parsed.hash)
+        throw new Error("Private registry URLs must not contain credentials, query, or fragment data.");
+    if (!/^[A-Z_][A-Z0-9_]*$/.test(tokenEnv))
+        throw new Error("Invalid private registry token_env.");
+    return { name, url: parsed.toString().replace(/\/$/, ""), tokenEnv };
+}
+function assertSchema(content, label) {
+    if (scalar(content, "schema") !== "1")
+        throw new Error(`${label} schema must be version 1.`);
+}
+function scalar(content, key) {
+    return content.match(new RegExp(`^${key}:[ \\t]*([^\\r\\n]*)$`, "m"))?.[1]?.trim() ?? "";
+}
+function normalizedList(content, key, label) {
+    const value = scalar(content, key);
+    if (!value.startsWith("[") || !value.endsWith("]"))
+        throw new Error(`${label} ${key} must be an inline list.`);
+    return [
+        ...new Set(value
+            .slice(1, -1)
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean)),
+    ].sort();
+}

package/dist/telemetry.d.ts

@@ -0,0 +1,20 @@
+import type { CommandResult, FileSystem } from "./types.js";
+export type TelemetryConfig = {
+    schema: 1;
+    enabled: boolean;
+    includeCommand: boolean;
+    includeOutcome: boolean;
+};
+export type TelemetryEvent = {
+    schema: 1;
+    command?: string;
+    outcome?: "success" | "failure";
+};
+export interface TelemetryClient {
+    record(event: TelemetryEvent): Promise<void>;
+}
+export declare const DEFAULT_TELEMETRY_CONFIG: TelemetryConfig;
+export declare function parseTelemetryConfig(content: string): TelemetryConfig;
+export declare function serializeTelemetryConfig(config: TelemetryConfig): string;
+export declare function createTelemetryEvent(command: string | undefined, result: CommandResult, config: TelemetryConfig): TelemetryEvent | undefined;
+export declare function recordConfiguredTelemetry(fs: FileSystem, configPath: string, client: TelemetryClient | undefined, command: string | undefined, result: CommandResult): Promise<void>;

package/dist/telemetry.js

@@ -0,0 +1,95 @@
+export const DEFAULT_TELEMETRY_CONFIG = {
+    schema: 1,
+    enabled: false,
+    includeCommand: true,
+    includeOutcome: true,
+};
+const TELEMETRY_COMMANDS = new Set([
+    "adr",
+    "audit-package",
+    "brainstorm",
+    "capabilities",
+    "confirm",
+    "context",
+    "context-quality",
+    "context-summary",
+    "doctor",
+    "gate",
+    "generate",
+    "install",
+    "organization-policy",
+    "plan",
+    "plugin",
+    "policy-check",
+    "preset",
+    "recommend",
+    "registry",
+    "repair",
+    "resolve",
+    "rollback",
+    "scan",
+    "self-validate",
+    "skills",
+    "spec",
+    "status",
+    "sync",
+    "target",
+    "telemetry",
+    "token-usage",
+    "trace",
+    "uninstall",
+    "update",
+    "validate",
+    "verify",
+    "verify-package",
+]);
+export function parseTelemetryConfig(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines.at(-1) === "")
+        lines.pop();
+    if (lines[0] !== "schema: 1")
+        throw new Error("Telemetry schema must be version 1.");
+    if (lines.length !== 5)
+        throw new Error("Telemetry configuration structure is invalid.");
+    if (lines[2] !== "privacy:")
+        throw new Error("Telemetry privacy section is required.");
+    return {
+        schema: 1,
+        enabled: booleanLine(lines[1], /^enabled: (true|false)$/, "enabled"),
+        includeCommand: booleanLine(lines[3], /^[ ]{2}include_command: (true|false)$/, "include_command"),
+        includeOutcome: booleanLine(lines[4], /^[ ]{2}include_outcome: (true|false)$/, "include_outcome"),
+    };
+}
+export function serializeTelemetryConfig(config) {
+    return `schema: 1\nenabled: ${config.enabled}\nprivacy:\n  include_command: ${config.includeCommand}\n  include_outcome: ${config.includeOutcome}\n`;
+}
+export function createTelemetryEvent(command, result, config) {
+    if (!config.enabled)
+        return undefined;
+    return {
+        schema: 1,
+        ...(config.includeCommand ? { command: safeCommand(command) } : {}),
+        ...(config.includeOutcome ? { outcome: result.exitCode === 0 ? "success" : "failure" } : {}),
+    };
+}
+export async function recordConfiguredTelemetry(fs, configPath, client, command, result) {
+    if (!client || !fs.exists(configPath))
+        return;
+    try {
+        const event = createTelemetryEvent(command, result, parseTelemetryConfig(fs.read(configPath)));
+        if (event)
+            await client.record(event);
+    }
+    catch {
+        // Telemetry must never affect the requested workflow operation.
+    }
+}
+function safeCommand(command) {
+    return command && TELEMETRY_COMMANDS.has(command) ? command : "unknown";
+}
+function booleanLine(line, pattern, key) {
+    const parsed = line?.match(pattern)?.[1];
+    if (!parsed)
+        throw new Error(`Telemetry field '${key}' must be true or false.`);
+    return parsed === "true";
+}

package/dist/token-usage.d.ts

@@ -0,0 +1,9 @@
+export type TokenUsage = {
+    stage: string;
+    budget: number;
+    used: number;
+};
+export declare function validateTokenUsage(usage: TokenUsage): TokenUsage;
+export declare function parseTokenUsage(content: string): TokenUsage[];
+export declare function serializeTokenUsage(entries: TokenUsage[]): string;
+export declare function recordTokenUsage(entries: TokenUsage[], usage: TokenUsage): TokenUsage[];

package/dist/token-usage.js

@@ -0,0 +1,38 @@
+export function validateTokenUsage(usage) {
+    if (!usage.stage.trim())
+        throw new Error("Token usage stage must not be empty.");
+    for (const [name, value] of [
+        ["budget", usage.budget],
+        ["used", usage.used],
+    ]) {
+        if (!Number.isInteger(value) || value < 0)
+            throw new Error(`Token ${name} must be a non-negative integer.`);
+    }
+    if (usage.used > usage.budget)
+        throw new Error(`Token budget exceeded for stage: ${usage.stage}`);
+    return usage;
+}
+export function parseTokenUsage(content) {
+    if (!content.trim())
+        return [];
+    return content
+        .split("\n")
+        .slice(1)
+        .filter(Boolean)
+        .map((line) => {
+        const [stage, budget, used] = line.split("|");
+        return validateTokenUsage({ stage, budget: Number(budget), used: Number(used) });
+    });
+}
+export function serializeTokenUsage(entries) {
+    return ([
+        "schema: 1",
+        ...entries
+            .sort((a, b) => a.stage.localeCompare(b.stage))
+            .map((entry) => `${entry.stage}|${entry.budget}|${entry.used}`),
+    ].join("\n") + "\n");
+}
+export function recordTokenUsage(entries, usage) {
+    validateTokenUsage(usage);
+    return [...entries.filter((entry) => entry.stage !== usage.stage), usage];
+}

package/dist/traceability.d.ts

@@ -0,0 +1,23 @@
+export type TraceabilityLink = {
+    requirement: string;
+    decisions: string[];
+    tasks: string[];
+    code: string[];
+    tests: string[];
+    evidence: string[];
+};
+export type TraceabilityGraph = {
+    schema: 1;
+    links: TraceabilityLink[];
+};
+type TraceabilityInput = {
+    specification: string;
+    plan: string;
+    decisions: {
+        id: string;
+        content: string;
+    }[];
+};
+export declare function buildTraceabilityGraph(input: TraceabilityInput): TraceabilityGraph;
+export declare function serializeTraceabilityGraph(graph: TraceabilityGraph, requirement?: string): string;
+export {};

package/dist/traceability.js

@@ -0,0 +1,51 @@
+const uniqueSorted = (values) => [...new Set(values)].sort();
+function valuesForField(block, field) {
+    const expression = new RegExp(`^\\s*-?\\s*${field}:\\s*(.+)$`, "gim");
+    return [...block.matchAll(expression)].map((match) => match[1].trim());
+}
+export function buildTraceabilityGraph(input) {
+    const requirements = uniqueSorted(input.specification.match(/REQ-\d+/g) ?? []);
+    const taskStarts = [...input.plan.matchAll(/(?:^|\n)\s*-?\s*(?:\[[ x]\]\s*)?(TASK-\d+)/gi)];
+    const tasks = taskStarts.map((match, index) => ({
+        id: match[1],
+        block: input.plan.slice(match.index, taskStarts[index + 1]?.index ?? input.plan.length),
+    }));
+    const globalValidation = uniqueSorted([
+        ...valuesForField(input.plan, "Validation"),
+        ...(input.plan.match(/npm (?:run )?[\w:-]+/g) ?? []),
+    ]);
+    return {
+        schema: 1,
+        links: requirements.map((requirement) => {
+            const linkedTasks = tasks.filter(({ block }) => block.includes(requirement));
+            return {
+                requirement,
+                decisions: uniqueSorted(input.decisions
+                    .filter(({ content }) => content.includes(requirement))
+                    .map(({ id }) => id)),
+                tasks: uniqueSorted(linkedTasks.map(({ id }) => id)),
+                code: uniqueSorted(linkedTasks.flatMap(({ block }) => valuesForField(block, "Code"))),
+                tests: uniqueSorted(linkedTasks.flatMap(({ block }) => valuesForField(block, "Tests"))),
+                evidence: uniqueSorted([
+                    ...linkedTasks.flatMap(({ block }) => valuesForField(block, "Evidence")),
+                    ...(linkedTasks.length > 0 ? globalValidation : []),
+                ]),
+            };
+        }),
+    };
+}
+function yamlList(values) {
+    return `[${values
+        .map((value) => (/^(?:REQ|ADR|TASK)-\d+$/.test(value) ? value : JSON.stringify(value)))
+        .join(", ")}]`;
+}
+export function serializeTraceabilityGraph(graph, requirement) {
+    const links = requirement
+        ? graph.links.filter((link) => link.requirement === requirement)
+        : graph.links;
+    if (requirement && links.length === 0)
+        throw new Error(`Requirement not found: ${requirement}`);
+    return `schema: 1\nlinks:\n${links
+        .map((link) => `  - requirement: ${link.requirement}\n    decisions: ${yamlList(link.decisions)}\n    tasks: ${yamlList(link.tasks)}\n    code: ${yamlList(link.code)}\n    tests: ${yamlList(link.tests)}\n    evidence: ${yamlList(link.evidence)}`)
+        .join("\n")}\n`;
+}