create-agdf 0.10.1 → 0.10.3

package/generated/plugins/agdf/runtime/create-agdf/lib/control-state/run-state-parser.js

@@ -0,0 +1,227 @@
+export const RUN_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+export const LIFECYCLES = new Set([
+  "active",
+  "completed",
+  "superseded",
+  "abandoned",
+]);
+export function scalarFields(content) {
+  const values = new Map(),
+    duplicates = [];
+  const runMeta = content.match(/(?:^|\n)## Run Meta\s*\n([\s\S]*?)(?=\n## |$)/)?.[1] ?? "";
+  for (const [, k, v] of runMeta.matchAll(/^- ([a-z_]+):\s*(.*?)\s*$/gm)) {
+    if (values.has(k)) duplicates.push(k);
+    else values.set(k, v.replace(/^`|`$/g, ""));
+  }
+  return { values, duplicates };
+}
+export function parseRunState(content, expected) {
+  const { values, duplicates } = scalarFields(content),
+    findings = duplicates.map((field) => ({
+      code: "AGDF_RUN_FIELD_DUPLICATE",
+      field,
+    })),
+    id = values.get("run_id") ?? "";
+  if (content.split(/\r?\n/).some((line) => line.trimStart().startsWith("|") && !line.trimEnd().endsWith("|"))) {
+    findings.push({ code: "AGDF_RUN_TABLE_INVALID" });
+  }
+  if (!RUN_ID_PATTERN.test(id)) findings.push({ code: "AGDF_RUN_ID_INVALID" });
+  if (expected && id !== expected)
+    findings.push({ code: "AGDF_RUN_PATH_MISMATCH" });
+  if (values.get("control_state_version") !== "2")
+    findings.push({ code: "AGDF_RUN_VERSION_UNSUPPORTED" });
+  if (!LIFECYCLES.has(values.get("lifecycle")))
+    findings.push({ code: "AGDF_RUN_LIFECYCLE_INVALID" });
+  if (!/^[1-9]\d*$/.test(values.get("revision") ?? ""))
+    findings.push({ code: "AGDF_RUN_REVISION_INVALID" });
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(values.get("revision_id") ?? ""))
+    findings.push({ code: "AGDF_RUN_REVISION_ID_INVALID" });
+  return {
+    content,
+    meta: Object.fromEntries(values),
+    findings,
+    valid: !findings.length,
+  };
+}
+export function semanticBody(content) {
+  return content
+    .replace(/^# AGDF Run State\s*/m, "")
+    .replace(/## Run Meta[\s\S]*?(?=\n## )/, "")
+    .trim();
+}
+export function semanticFingerprint(content) {
+  return semanticBody(content).replace(/\s+/g, " ");
+}
+
+function section(c, h) {
+  const e = h.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return (
+    c.match(
+      new RegExp(`(?:^|\\n)## ${e}\\s*\\n([\\s\\S]*?)(?:\\n## |\\n# |$)`),
+    )?.[1] ?? ""
+  );
+}
+function rows(s) {
+  return s
+    .split(/\r?\n/)
+    .filter((l) => l.trim().startsWith("|"))
+    .map((l) =>
+      l
+        .split("|")
+        .slice(1, -1)
+        .map((x) => x.trim()),
+    )
+    .filter((r) => !r.every((x) => /^[-:]+$/.test(x)));
+}
+function clean(v = "") {
+  return v.replace(/^`|`$/g, "").trim();
+}
+export function parseArtefactPathCell(value = "") {
+  const raw = String(value).trim();
+  if (!raw) return { raw, path: "", format: "plain", reason: "empty" };
+  const ticks = [...raw].filter((character) => character === "`").length;
+  if (ticks === 0) return { raw, path: raw, format: "plain", reason: "none" };
+  if (ticks === 2 && raw.startsWith("`") && raw.endsWith("`")) {
+    const path = raw.slice(1, -1).trim();
+    if (path && !path.includes("`")) return { raw, path, format: "code_span", reason: "none" };
+  }
+  return {
+    raw,
+    path: "",
+    format: "invalid",
+    reason: ticks === 1 || raw.startsWith("`") !== raw.endsWith("`")
+      ? "unmatched_delimiter"
+      : "embedded_delimiter",
+  };
+}
+function meaningful(v = "") {
+  return Boolean(v && !(v.startsWith("`") && v.includes("|")));
+}
+function field(c, k) {
+  return (
+    c.match(new RegExp(`^- ${k}:[^\\S\\r\\n]*(.*)$`, "m"))?.[1]?.trim() ?? ""
+  );
+}
+function sectionField(c, h, k) {
+  return field(section(c, h), k);
+}
+function dataRows(c, h, header) {
+  return rows(section(c, h)).filter(
+    (r) =>
+      r[0] !== header &&
+      (h === "Evidence" ? r.slice(0, 3).some(meaningful) : r.some(meaningful)),
+  );
+}
+export function parseControlState(
+  content,
+  { userGates = [], internalSteps = [], closeoutArtefacts = [] } = {},
+) {
+  const approvals = new Map();
+  for (const h of ["Approvals", "Gate Checklist"])
+    for (const [g, s, e] of rows(section(content, h))) {
+      if (userGates.includes(g)) {
+        const status = clean(s);
+        approvals.set(g, {
+          status: g === "QA" && (status === "pass" || status === "passed") ? "approved" : status,
+          evidence: e ?? "",
+        });
+      }
+    }
+  const artefacts = new Map();
+  for (const [t, p, s, n] of rows(section(content, "Artefacts"))) {
+    if (userGates.includes(t) || internalSteps.includes(t) || closeoutArtefacts.includes(t)) {
+      const parsedPath = parseArtefactPathCell(p ?? "");
+      artefacts.set(t, {
+        path: parsedPath.path,
+        status: clean(s),
+        notes: n ?? "",
+        raw_path: parsedPath.raw,
+        path_format: parsedPath.format,
+        path_reason: parsedPath.reason,
+      });
+    }
+  }
+  const mapRows = (h, header, fn) => dataRows(content, h, header).map(fn);
+  const mode = section(content, "Mode/Slice Decision").trim()
+      ? "Mode/Slice Decision"
+      : "Mode / Slice Decision",
+    source = "Source And Scope State",
+    memory = "Knowledge Persistence Decision";
+  return {
+    current_gate: field(content, "current_gate"),
+    next_allowed_action: field(content, "next_allowed_action"),
+    approvals,
+    artefacts,
+    evidence_refs: mapRows("Evidence", "Evidence", (r) => ({
+      evidence: r[0] ?? "",
+      source: r[1] ?? "",
+      covers: r[2] ?? "",
+      strength: clean(r[3]),
+    })),
+    artefact_chain: mapRows("Artefact Chain", "From", (r) => ({
+      from: r[0] ?? "",
+      relationship: clean(r[1]),
+      to: clean(r[2]),
+      evidence: r[3] ?? "",
+    })),
+    missing_evidence: mapRows("Missing Evidence", "Missing evidence", (r) => ({
+      missing_evidence: r[0] ?? "",
+      impact: clean(r[1]),
+      required_next_step: r[2] ?? "",
+    })),
+    risks: mapRows("Risks", "Risk", (r) => ({
+      risk: r[0] ?? "",
+      impact: clean(r[1]),
+      mitigation_or_owner: r[2] ?? "",
+    })),
+    context_graph: {
+      impact: clean(field(content, "context_graph_impact")),
+      refs: field(content, "context_graph_refs"),
+      required_action: clean(field(content, "context_graph_required_action")),
+      gate_effect: clean(field(content, "context_graph_gate_effect")),
+      evidence: field(content, "context_graph_evidence"),
+    },
+    quality_outlook: field(content, "quality_outlook"),
+    mode_slice_decision: {
+      decision: clean(sectionField(content, mode, "decision")),
+      required_next_gate: clean(
+        sectionField(content, mode, "required_next_gate"),
+      ),
+      scope_reason: sectionField(content, mode, "scope_reason"),
+      evidence: sectionField(content, mode, "evidence"),
+    },
+    source_scope: {
+      normative_instruction_source: sectionField(
+        content,
+        source,
+        "normative_instruction_source",
+      ),
+      multi_scope_state: clean(
+        sectionField(content, source, "multi_scope_state"),
+      ),
+      active_scope_evidence: sectionField(
+        content,
+        source,
+        "active_scope_evidence",
+      ),
+      competing_scope_lines: sectionField(
+        content,
+        source,
+        "competing_scope_lines",
+      ),
+      branch_workspace_evidence: sectionField(
+        content,
+        source,
+        "branch_workspace_evidence",
+      ),
+      branch_workspace_scope_effect: clean(
+        sectionField(content, source, "branch_workspace_scope_effect"),
+      ),
+    },
+    memory: {
+      target: clean(sectionField(content, memory, "memory_target")),
+      reason: sectionField(content, memory, "memory_reason"),
+      refs: sectionField(content, memory, "memory_refs"),
+    },
+  };
+}

package/generated/plugins/agdf/runtime/create-agdf/lib/control-state/run-state-repository.js

@@ -0,0 +1,68 @@
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { parseRunState, RUN_ID_PATTERN } from "./run-state-parser.js";
+export function runPath(root, id) {
+  if (!RUN_ID_PATTERN.test(id)) throw Error(`invalid run_id: ${id}`);
+  return join(root, ".agdf", "control", "runs", id, "RUN_STATE.md");
+}
+export function discoverRuns(root) {
+  const dir = join(root, ".agdf", "control", "runs");
+  if (!existsSync(dir)) return [];
+  const rootStats = lstatSync(dir);
+  if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
+    return [invalidRun("<repository>", dir)];
+  }
+  return readdirSync(dir)
+    .filter((x) => !x.startsWith("."))
+    .sort()
+    .map((id) => {
+      const d = join(dir, id),
+        path = join(d, "RUN_STATE.md");
+      const directoryStats = lstatSync(d);
+      if (
+        !RUN_ID_PATTERN.test(id) ||
+        directoryStats.isSymbolicLink() ||
+        !directoryStats.isDirectory() ||
+        !existsSync(path)
+      )
+        return invalidRun(id, path);
+
+      const stateStats = lstatSync(path);
+      if (stateStats.isSymbolicLink() || !stateStats.isFile()) {
+        return invalidRun(id, path);
+      }
+      return {
+        run_id: id,
+        path,
+        ...parseRunState(readFileSync(path, "utf8"), id),
+      };
+    });
+}
+
+function invalidRun(runId, path) {
+  return {
+    run_id: runId,
+    path,
+    valid: false,
+    findings: [{ code: "AGDF_RUN_PATH_INVALID", path }],
+  };
+}
+const DEFAULT_BODY = `## Objective\n\nDescribe the trustworthy outcome.\n\n## Current Control State\n\n| Question | Answer |\n|---|---|\n| What is known? | New run created. |\n| What is approved? | Nothing yet. |\n| What is missing? | Durable UR and exact approval. |\n| What is the next allowed action? | Draft the UR. |\n| What is explicitly forbidden right now? | Later artefacts and implementation. |\n\n## Evidence\n\n| Evidence | Source | Covers | Strength |\n|---|---|---|---|\n| Run creation | run-create | Control initialization | direct |\n\n## Closeout\n\n- next_allowed_action: Draft the UR.\n- quality_outlook: Establish evidence before later gates.\n`;
+export function renderRunState(id, body = DEFAULT_BODY, meta = {}) {
+  return `# AGDF Run State\n\n## Run Meta\n\n- control_state_version: 2\n- run_id: ${id}\n- lifecycle: ${meta.lifecycle ?? "active"}\n- revision: 1\n- revision_id: ${randomUUID()}\n- mode: ${meta.mode ?? "structured_delivery"}\n- current_gate: ${meta.current_gate ?? "UR"}\n- decision: ${meta.decision ?? "in_progress"}\n- owner: ${meta.owner ?? "agent"}\n\n${body}`;
+}
+export function createRun(root, id, body = "") {
+  const path = runPath(root, id);
+  if (existsSync(path)) throw Error("AGDF_RUN_COLLISION");
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, renderRunState(id, body), { flag: "wx" });
+  return path;
+}

package/generated/plugins/agdf/runtime/create-agdf/lib/control-state/run-state-resolver.js

@@ -0,0 +1,45 @@
+import { discoverRuns } from "./run-state-repository.js";
+export function resolveRuns(
+  root,
+  { runIdArg, runIdEnv, allActive = false } = {},
+) {
+  if (
+    (allActive && (runIdArg || runIdEnv)) ||
+    (runIdArg && runIdEnv && runIdArg !== runIdEnv)
+  )
+    throw Error("AGDF_SELECTOR_CONFLICT");
+  const runs = discoverRuns(root),
+    active = runs.filter((r) => r.valid && r.meta.lifecycle === "active");
+  const findings = runs
+    .filter((run) => !run.valid)
+    .flatMap((run) =>
+      run.findings.map((finding) => ({ ...finding, run_id: run.run_id })),
+    );
+  if (allActive)
+    return { selection_source: "all_active", runs: active, findings };
+  const id = runIdArg || runIdEnv;
+  if (id) {
+    const run = runs.find((r) => r.run_id === id);
+    if (!run?.valid) {
+      throw Error(
+        `AGDF_RUN_NOT_SELECTABLE:${id}; discovered=${runs.map((item) => item.run_id).join(",")}; next=select a valid run`,
+      );
+    }
+    return {
+      selection_source: runIdArg ? "cli" : "environment",
+      run,
+      active_run_ids: active.map((r) => r.run_id),
+    };
+  }
+  if (active.length !== 1)
+    throw Error(
+      active.length
+        ? `AGDF_ACTIVE_RUN_AMBIGUOUS:${active.map((r) => r.run_id)}`
+        : "AGDF_ACTIVE_RUN_MISSING",
+    );
+  return {
+    selection_source: "single_active",
+    run: active[0],
+    active_run_ids: [active[0].run_id],
+  };
+}

package/generated/plugins/agdf/runtime/create-agdf/lib/control-state/run-state-writer.js

@@ -0,0 +1,97 @@
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  fsyncSync,
+  existsSync,
+  lstatSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+
+import { parseRunState } from "./run-state-parser.js";
+
+function fsyncDirectory(path) {
+  if (process.platform === "win32") return;
+  const descriptor = openSync(path, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+export function atomicWrite(path, content) {
+  if (existsSync(path)) {
+    const destination = lstatSync(path);
+    if (destination.isSymbolicLink() || !destination.isFile()) {
+      throw new Error("AGDF_RUN_PATH_INVALID");
+    }
+  }
+
+  const parent = lstatSync(dirname(path));
+  if (parent.isSymbolicLink() || !parent.isDirectory()) {
+    throw new Error("AGDF_RUN_PATH_INVALID");
+  }
+
+  const temp = `${path}.tmp-${process.pid}-${randomUUID()}`;
+  let descriptor;
+
+  try {
+    descriptor = openSync(temp, "wx");
+    writeFileSync(descriptor, content, "utf8");
+    fsyncSync(descriptor);
+    closeSync(descriptor);
+    descriptor = undefined;
+
+    renameSync(temp, path);
+    fsyncDirectory(dirname(path));
+  } catch (error) {
+    if (descriptor !== undefined) closeSync(descriptor);
+    try {
+      unlinkSync(temp);
+    } catch (cleanupError) {
+      if (cleanupError.code !== "ENOENT") throw cleanupError;
+    }
+    throw error;
+  }
+}
+
+export function writeRun(path, content, expectedRevisionId) {
+  const lockPath = `${path}.lock`;
+  let lockDescriptor;
+  try {
+    lockDescriptor = openSync(lockPath, "wx");
+  } catch (error) {
+    if (error.code === "EEXIST") throw new Error("AGDF_RUN_WRITE_LOCKED");
+    throw error;
+  }
+
+  try {
+    const current = parseRunState(readFileSync(path, "utf8"));
+    if (!current.valid) throw new Error("AGDF_RUN_STATE_INVALID");
+    if (current.meta.revision_id !== expectedRevisionId) {
+      throw new Error("AGDF_STALE_RUN_REVISION");
+    }
+
+    const next = content
+      .replace(
+        /^- revision:\s*.*$/m,
+        `- revision: ${Number(current.meta.revision) + 1}`,
+      )
+      .replace(/^- revision_id:\s*.*$/m, `- revision_id: ${randomUUID()}`);
+    const candidate = parseRunState(next);
+    if (!candidate.valid || candidate.meta.run_id !== current.meta.run_id) {
+      throw new Error("AGDF_RUN_STATE_INVALID");
+    }
+
+    atomicWrite(path, next);
+    return candidate;
+  } finally {
+    closeSync(lockDescriptor);
+    unlinkSync(lockPath);
+  }
+}

package/generated/plugins/agdf/runtime/create-agdf/lib/delivery-path-search/candidate-policy.js

@@ -0,0 +1,99 @@
+import { validateCandidate } from "./contracts.js";
+
+function normalized(value) {
+  return String(value).normalize("NFKC").toLowerCase().replace(/[`*_]/g, "").replace(/[^\p{L}\p{N}\s-]/gu, " ").replace(/\s+/g, " ").trim();
+}
+
+const STOP_WORDS = new Set(["a", "an", "and", "der", "die", "das", "ein", "eine", "the", "to", "und", "zu"]);
+
+function tokens(value) {
+  return new Set(normalized(value).split(/\s+/).filter((item) => item && !STOP_WORDS.has(item)));
+}
+
+function jaccard(left, right) {
+  const union = new Set([...left, ...right]);
+  if (!union.size) return 1;
+  let intersection = 0;
+  for (const item of left) if (right.has(item)) intersection += 1;
+  return intersection / union.size;
+}
+
+function signature(candidate) {
+  return JSON.stringify({
+    gate_action: normalized(candidate.gate_action ?? candidate.action),
+    affected_boundaries: [...(candidate.affected_boundaries ?? [])].map(normalized).sort(),
+    evidence: [...(candidate.expected_evidence ?? [])].map(normalized).sort(),
+    tests: [...(candidate.tests ?? [])].map(normalized).sort(),
+    risk_strategy: normalized(candidate.risk_strategy ?? ""),
+    reversibility: normalized(candidate.reversibility ?? ""),
+  });
+}
+
+export function candidateLegality(candidateValue, input) {
+  const candidate = validateCandidate(candidateValue);
+  const action = normalized(candidate.gate_action ?? candidate.action);
+  const forbiddenMatch = input.forbidden_actions.find((item) => {
+    const forbidden = normalized(item);
+    return forbidden && action === forbidden;
+  });
+  if (forbiddenMatch) return { legal: false, reason: `forbidden_by_gate: ${forbiddenMatch}`, candidate };
+
+  const allowedMatch = input.allowed_actions.some((item) => {
+    const allowed = normalized(item);
+    return allowed && action === allowed;
+  });
+  if (!allowedMatch) return { legal: false, reason: "not_in_allowed_actions", candidate };
+  return { legal: true, reason: "allowed_by_current_gate", candidate };
+}
+
+export function candidatesFromInput(input) {
+  return input.allowed_actions.slice(0, input.budgets.max_candidates).map((action, index) => ({
+    id: `candidate-${index + 1}`,
+    action,
+    expected_evidence: input.evidence_refs,
+    tests: [],
+    assumptions: [],
+    depth: 0,
+    parent_id: null,
+  }));
+}
+
+export function generatedCandidatesFromResponse(response, input, existingCandidates = []) {
+  const accepted = [];
+  const rejected = [];
+  for (const proposal of response.proposals) {
+    const candidate = {
+      id: `generated-${proposal.proposal_id}`,
+      action: proposal.intent,
+      source: "generated",
+      gate_action: proposal.gate_action,
+      intent: proposal.intent,
+      expected_evidence: proposal.expected_evidence,
+      tests: proposal.tests,
+      assumptions: proposal.assumptions,
+      affected_boundaries: proposal.affected_boundaries,
+      risk_strategy: proposal.risk_strategy,
+      reversibility: proposal.reversibility,
+      generator_proposal_id: proposal.proposal_id,
+      depth: 0,
+      parent_id: null,
+    };
+    const legality = candidateLegality(candidate, input);
+    if (!legality.legal) {
+      rejected.push({ proposal_id: proposal.proposal_id, reason: legality.reason });
+      continue;
+    }
+    const peers = [...existingCandidates, ...accepted].filter((item) => normalized(item.gate_action ?? item.action) === normalized(candidate.gate_action));
+    const duplicate = peers.find((item) => {
+      const same = normalized(item.intent ?? item.action) === normalized(candidate.intent);
+      const sameDecision = signature(item) === signature(candidate);
+      return same || sameDecision || jaccard(tokens(item.intent ?? item.action), tokens(candidate.intent)) >= 0.8;
+    });
+    if (duplicate) {
+      rejected.push({ proposal_id: proposal.proposal_id, reason: "cosmetic_or_material_duplicate" });
+      continue;
+    }
+    accepted.push(candidate);
+  }
+  return { accepted, rejected };
+}