@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-R2W3LESH.js

@@ -0,0 +1,465 @@
+import {
+  PromptStore,
+  assertSafePromptId,
+  assertSafeVersionId,
+  readInlineVersionContent
+} from "./chunk-GAB6UW52.js";
+import {
+  sqlite_wrapper_default
+} from "./chunk-XQPEWJPI.js";
+import {
+  getBuiltinWorkflowsDir
+} from "./chunk-STW7OFOA.js";
+import {
+  debugLog,
+  resolveBuildDirFromContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/prompts/execution-contract.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/automation/workflow-builtin-prompt-seed.ts
+import * as fs from "fs";
+import * as path from "path";
+import yaml from "js-yaml";
+
+// src/prompts/prompt-asset-index.ts
+import { createHash } from "crypto";
+function hashPromptAssetContent(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function normalizeContentHash(contentHash, content) {
+  const normalized = contentHash.trim().toLowerCase();
+  if (/^[a-f0-9]{64}$/.test(normalized)) return `sha256:${normalized}`;
+  if (/^sha256:[a-f0-9]{64}$/.test(normalized)) return normalized;
+  if (content !== void 0) return hashPromptAssetContent(content);
+  throw new Error("Stored prompt version has an invalid content hash");
+}
+function describeStoredPromptAsset(prompt, version) {
+  if (version.promptId !== prompt.id) {
+    throw new Error(`Prompt version ${version.id} does not belong to ${prompt.id}`);
+  }
+  return {
+    id: `store.${prompt.id}.${version.id}`,
+    owner: "prompt-store",
+    assetClass: "task-skill-content",
+    source: { kind: "store", locator: `${prompt.id}@${version.id}` },
+    provenance: {
+      hash: normalizeContentHash(version.contentHash, version.content),
+      version: version.id
+    },
+    inputContract: "stored prompt content",
+    outputContract: "task or workflow instruction text",
+    overridePolicy: "versioned-store",
+    sensitivity: "sensitive-input",
+    stability: version.isActive ? "stable" : "experimental"
+  };
+}
+function buildPromptAssetIndex(additionalAssets = []) {
+  const index = /* @__PURE__ */ new Map();
+  for (const asset of additionalAssets) {
+    if (index.has(asset.id)) {
+      throw new Error(`Duplicate prompt asset id: ${asset.id}`);
+    }
+    index.set(asset.id, asset);
+  }
+  return index;
+}
+
+// src/automation/workflow-builtin-prompt-seed.ts
+var BUILTIN_SOURCE_HASH_TAG = "builtin:source-sha256:";
+var BUILTIN_PINNED_TAG = "builtin:pinned";
+function hashContent(content) {
+  return hashPromptAssetContent(content).slice("sha256:".length);
+}
+function sourceHashFromTags(tags) {
+  const tag = tags.find((candidate) => candidate.startsWith(BUILTIN_SOURCE_HASH_TAG));
+  const hash = tag?.slice(BUILTIN_SOURCE_HASH_TAG.length).toLowerCase();
+  return hash && /^[a-f0-9]{64}$/.test(hash) ? hash : void 0;
+}
+function parseSkillMarkdown(skillId, raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match?.[1] || match[2] === void 0) {
+    throw new Error(`Invalid SKILL.md for ${skillId}: missing YAML frontmatter`);
+  }
+  const frontmatter = yaml.load(match[1]);
+  if (frontmatter === null || typeof frontmatter !== "object") {
+    throw new Error(`Invalid SKILL.md for ${skillId}: frontmatter must be an object`);
+  }
+  const meta = frontmatter;
+  const name = typeof meta.name === "string" && meta.name.trim() !== "" ? meta.name : skillId;
+  const description = typeof meta.description === "string" && meta.description.trim() !== "" ? meta.description : `Built-in skill ${skillId}`;
+  return {
+    id: skillId,
+    name,
+    description,
+    body: match[2].trim()
+  };
+}
+function listPackagedSkills(builtinWorkflowsDir, opts) {
+  const skillsRoot = path.join(builtinWorkflowsDir, "skills");
+  const warnings = [];
+  if (!fs.existsSync(skillsRoot)) {
+    return { skills: [], warnings };
+  }
+  const wanted = opts?.skillIds ? new Set(opts.skillIds) : void 0;
+  const skills = [];
+  for (const entry of fs.readdirSync(skillsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    if (wanted && !wanted.has(entry.name)) {
+      continue;
+    }
+    const skillFile = path.join(skillsRoot, entry.name, "SKILL.md");
+    if (!fs.existsSync(skillFile)) {
+      debugLog("Skipping builtin skill without SKILL.md: %s", skillFile);
+      continue;
+    }
+    try {
+      const raw = fs.readFileSync(skillFile, "utf-8");
+      skills.push(parseSkillMarkdown(entry.name, raw));
+    } catch (error) {
+      const message = `Packaged builtin skill '${entry.name}' could not be loaded and was skipped: ${error instanceof Error ? error.message : String(error)}`;
+      debugLog("%s", message);
+      warnings.push(message);
+      opts?.onWarning?.(message);
+    }
+  }
+  return { skills, warnings };
+}
+function readPackagedBuiltinSkill(builtinWorkflowsDir, skillId) {
+  const { skills } = listPackagedSkills(builtinWorkflowsDir, { skillIds: [skillId] });
+  const skill = skills[0];
+  return skill ? { ...skill, packagedHash: hashContent(skill.body) } : void 0;
+}
+function classifyStoredBuiltin(store, promptId, packagedHash, comparedHash) {
+  const existing = store.getPrompt(promptId);
+  const activeVersion = store.getActiveVersion(promptId);
+  const seededFromHash = sourceHashFromTags(existing?.tags ?? []) ?? (activeVersion?.author === "build-builtin" ? activeVersion.contentHash.toLowerCase() : void 0);
+  let status;
+  if (existing?.tags.includes(BUILTIN_PINNED_TAG)) {
+    status = "pinned";
+  } else if (comparedHash === packagedHash) {
+    status = "current";
+  } else if (seededFromHash && comparedHash === seededFromHash) {
+    status = "upstream-update";
+  } else {
+    status = "local-customized";
+  }
+  return { status, ...seededFromHash ? { seededFromHash } : {} };
+}
+function checkResolvedPromptAgainstBuiltin(args) {
+  const resolvedHash = hashContent(args.content);
+  const packaged = args.builtinWorkflowsDir ? readPackagedBuiltinSkill(args.builtinWorkflowsDir, args.promptId) : void 0;
+  if (!packaged) {
+    return { promptId: args.promptId, status: "not-builtin", resolvedHash };
+  }
+  if (resolvedHash === packaged.packagedHash) {
+    return {
+      promptId: args.promptId,
+      status: "current",
+      resolvedHash,
+      packagedHash: packaged.packagedHash
+    };
+  }
+  const { status } = classifyStoredBuiltin(
+    args.store,
+    args.promptId,
+    packaged.packagedHash,
+    resolvedHash
+  );
+  if (status === "pinned") {
+    return {
+      promptId: args.promptId,
+      status,
+      resolvedHash,
+      packagedHash: packaged.packagedHash
+    };
+  }
+  const reason = status === "upstream-update" ? "the packaged builtin skill is newer than the stored version" : "the stored prompt has been locally customized";
+  return {
+    promptId: args.promptId,
+    status,
+    resolvedHash,
+    packagedHash: packaged.packagedHash,
+    warning: `Prompt '${args.promptId}@${args.versionId}' resolved from the local prompt store does not match the packaged builtin skill (${reason}). The local prompt takes precedence and was used. Run 'build prompt show ${args.promptId}' to inspect it.`
+  };
+}
+async function ensureBuiltinSkillsSeeded(builtinWorkflowsDir, opts) {
+  const store = opts?.store ?? new PromptStore();
+  const { skills } = listPackagedSkills(builtinWorkflowsDir, {
+    ...opts?.skillIds ? { skillIds: opts.skillIds } : {},
+    ...opts?.onWarning ? { onWarning: opts.onWarning } : {}
+  });
+  const results = [];
+  for (const skill of skills) {
+    const packagedHash = hashContent(skill.body);
+    const existing = store.getPrompt(skill.id);
+    if (existing) {
+      const activeHash = store.getActiveVersion(skill.id)?.contentHash.toLowerCase();
+      const { status, seededFromHash } = classifyStoredBuiltin(
+        store,
+        skill.id,
+        packagedHash,
+        activeHash
+      );
+      results.push({
+        id: skill.id,
+        status,
+        action: "unchanged",
+        packagedHash,
+        ...activeHash ? { activeHash } : {},
+        ...seededFromHash ? { seededFromHash } : {}
+      });
+      debugLog("Builtin skill lifecycle: %s (%s); leaving untouched", skill.id, status);
+      continue;
+    }
+    store.createPrompt({
+      id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      category: "workflow",
+      tags: ["builtin", `${BUILTIN_SOURCE_HASH_TAG}${packagedHash}`]
+    });
+    store.createVersion(skill.id, "v1", skill.body, {
+      changelog: "Imported from package builtin skill",
+      author: "build-builtin",
+      activate: true
+    });
+    debugLog("Seeded builtin skill prompt: %s", skill.id);
+    results.push({
+      id: skill.id,
+      status: "current",
+      action: "seeded",
+      packagedHash,
+      activeHash: packagedHash,
+      seededFromHash: packagedHash
+    });
+  }
+  return results;
+}
+
+// src/prompts/read-only-store.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function parseTags(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((tag) => typeof tag === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function promptStoreDbPath(buildDir) {
+  return path2.join(resolveBuildDirFromContext(buildDir), "prompts", "db", "prompts.db");
+}
+var ReadOnlyPromptStore = class _ReadOnlyPromptStore {
+  promptsDir;
+  db;
+  constructor(buildDir) {
+    this.promptsDir = path2.join(buildDir, "prompts");
+    if (!sqlite_wrapper_default) {
+      throw new Error("Database constructor not available");
+    }
+    this.db = new sqlite_wrapper_default(path2.join(this.promptsDir, "db", "prompts.db"), {
+      readonly: true,
+      fileMustExist: true
+    });
+    if (this.db.defaultSafeIntegers) {
+      this.db.defaultSafeIntegers(false);
+    }
+  }
+  /**
+   * Open the store for the given (or ambient) build dir, or return undefined
+   * when no database file exists. Absence is not a failure: it is the normal
+   * default-run state and must stay free of any filesystem write.
+   *
+   * Throws when the file exists but cannot be opened or read.
+   */
+  static openExisting(buildDir) {
+    const resolvedBuildDir = resolveBuildDirFromContext(buildDir);
+    if (!fs2.existsSync(promptStoreDbPath(resolvedBuildDir))) {
+      return void 0;
+    }
+    return new _ReadOnlyPromptStore(resolvedBuildDir);
+  }
+  getPrompt(id) {
+    const row = this.db.prepare("SELECT status, tags FROM prompts WHERE id = ?").get(id);
+    if (!row) return null;
+    return { status: row.status, tags: parseTags(row.tags) };
+  }
+  getActiveVersion(promptId) {
+    const row = this.db.prepare(
+      "SELECT id, content_hash, author FROM prompt_versions WHERE prompt_id = ? AND is_active = 1"
+    ).get(promptId);
+    return row ? toVersionRecord(row) : null;
+  }
+  getVersion(promptId, versionId) {
+    const row = this.db.prepare(
+      "SELECT id, content_hash, author FROM prompt_versions WHERE prompt_id = ? AND id = ?"
+    ).get(promptId, versionId);
+    return row ? toVersionRecord(row) : null;
+  }
+  /** Read the side-file or legacy inline content, matching PromptStore's precedence. */
+  getVersionContent(promptId, versionId, status) {
+    assertSafePromptId(promptId);
+    assertSafeVersionId(versionId);
+    const baseDir = path2.join(this.promptsDir, status === "archived" ? "archived" : "active");
+    const contentPath = path2.join(baseDir, `${promptId}-${versionId}.txt`);
+    if (!fs2.existsSync(contentPath)) {
+      const inline = readInlineVersionContent(this.db, promptId, versionId);
+      if (inline !== void 0) return inline;
+    }
+    return fs2.readFileSync(contentPath, "utf8");
+  }
+  close() {
+    this.db.close();
+  }
+};
+function toVersionRecord(row) {
+  return {
+    id: row.id,
+    contentHash: row.content_hash,
+    ...row.author === null ? {} : { author: row.author }
+  };
+}
+
+// src/prompts/execution-contract.ts
+var EXECUTION_CONTRACT_CODE_ID = "execution-contract-code";
+var EXECUTION_CONTRACT_ANALYSIS_ID = "execution-contract-analysis";
+var EXECUTION_CONTRACT_STRUCTURED_ID = "execution-contract-structured";
+function executionContractIdForIntent(executionIntent) {
+  return executionIntent === "analysis" ? EXECUTION_CONTRACT_ANALYSIS_ID : EXECUTION_CONTRACT_CODE_ID;
+}
+var FUSION_FENCE = /^[ \t]*<!--[ \t]*build:fusion-only:start[ \t]*-->[ \t]*\r?\n([\s\S]*?)^[ \t]*<!--[ \t]*build:fusion-only:end[ \t]*-->[ \t]*\r?\n?/gm;
+function applyFusionFence(text, isFusionRun) {
+  const fenced = text.replace(FUSION_FENCE, (_match, body) => isFusionRun ? body : "");
+  return fenced.replace(
+    /^[ \t]*<!--[ \t]*build:fusion-only:(?:start|end)[ \t]*-->[ \t]*\r?\n?/gm,
+    ""
+  );
+}
+function sha256(text) {
+  return createHash2("sha256").update(text, "utf8").digest("hex");
+}
+function tryReadPackagedContract(id) {
+  const builtinDir = getBuiltinWorkflowsDir();
+  const packaged = builtinDir ? readPackagedBuiltinSkill(builtinDir, id) : void 0;
+  return packaged ? { body: packaged.body } : void 0;
+}
+function readPackagedContract(id) {
+  const packaged = tryReadPackagedContract(id);
+  if (!packaged) {
+    throw new Error(
+      `Execution contract '${id}' is missing from the installed package (expected templates/builtin-workflows/skills/${id}/SKILL.md). Reinstall Build.`
+    );
+  }
+  return packaged;
+}
+function readStoredContract(id, version) {
+  let store;
+  try {
+    store = ReadOnlyPromptStore.openExisting();
+    if (!store) {
+      return { outcome: "absent" };
+    }
+    const prompt = store.getPrompt(id);
+    if (!prompt || prompt.status === "archived") {
+      return { outcome: "absent" };
+    }
+    const useActive = version === void 0 || version === "active" || version === "stable";
+    const resolved = useActive ? store.getActiveVersion(id) : store.getVersion(id, version);
+    if (!resolved) {
+      return { outcome: "absent" };
+    }
+    const text = store.getVersionContent(id, resolved.id, prompt.status);
+    const check = checkResolvedPromptAgainstBuiltin({
+      builtinWorkflowsDir: getBuiltinWorkflowsDir(),
+      promptId: id,
+      versionId: resolved.id,
+      content: text,
+      store
+    });
+    return {
+      outcome: "found",
+      text,
+      versionId: resolved.id,
+      status: check.status,
+      ...check.warning ? { warning: check.warning } : {}
+    };
+  } catch (error) {
+    return { outcome: "unreadable", error: error instanceof Error ? error.message : String(error) };
+  } finally {
+    store?.close();
+  }
+}
+function resolveExecutionContract(input = {}) {
+  const intentId = executionContractIdForIntent(input.executionIntent);
+  const requestedId = input.override?.id ?? intentId;
+  const isFusionRun = input.runSemantics === "fusion";
+  const stored = readStoredContract(requestedId, input.override?.version);
+  if (stored.outcome === "found") {
+    return finalize(requestedId, stored.versionId, stored.text, isFusionRun, {
+      source: "store",
+      status: stored.status,
+      ...stored.warning ? { warning: stored.warning } : {}
+    });
+  }
+  const packagedForRequested = tryReadPackagedContract(requestedId);
+  const resolvedId = packagedForRequested ? requestedId : intentId;
+  const body = packagedForRequested?.body ?? readPackagedContract(intentId).body;
+  const disclosure = {
+    source: "packaged",
+    status: "current"
+  };
+  const notes = [];
+  if (stored.outcome === "unreadable") {
+    disclosure.storeReadError = stored.error;
+    notes.push(
+      `the local prompt store could not be read (${stored.error}), so any stored customization of '${requestedId}' was not applied`
+    );
+  }
+  if (!packagedForRequested) {
+    disclosure.unavailableOverride = requestedId;
+    notes.push(
+      `the requested execution contract '${requestedId}' is neither in the prompt store nor packaged`
+    );
+  }
+  if (notes.length > 0) {
+    disclosure.warning = `Execution contract: ${notes.join("; ")}. The packaged '${resolvedId}' contract was used. Run 'build prompt show ${requestedId}' to inspect what the store holds.`;
+  }
+  return finalize(resolvedId, "packaged", body, isFusionRun, disclosure);
+}
+function finalize(id, versionId, raw, isFusionRun, disclosure) {
+  const text = applyFusionFence(raw, isFusionRun).trim();
+  return { id, versionId, sha256: sha256(text), text, disclosure };
+}
+function formatExecutionContractDisclosure(contract) {
+  return contract.disclosure.warning ? `Warning: ${contract.disclosure.warning}` : void 0;
+}
+function formatPromptContractRef(contract) {
+  return `${contract.id}@${contract.versionId}#${contract.sha256.slice(0, 12)}`;
+}
+function applyExecutionContract(basePrompt, contract) {
+  return `${basePrompt}
+
+${contract.text}`;
+}
+
+export {
+  describeStoredPromptAsset,
+  buildPromptAssetIndex,
+  readPackagedBuiltinSkill,
+  checkResolvedPromptAgainstBuiltin,
+  ensureBuiltinSkillsSeeded,
+  EXECUTION_CONTRACT_CODE_ID,
+  EXECUTION_CONTRACT_ANALYSIS_ID,
+  EXECUTION_CONTRACT_STRUCTURED_ID,
+  resolveExecutionContract,
+  formatExecutionContractDisclosure,
+  formatPromptContractRef,
+  applyExecutionContract
+};
+//# sourceMappingURL=chunk-R2W3LESH.js.map

package/dist/chunk-R5EXHMUN.js

@@ -0,0 +1,100 @@
+import {
+  getPlanningRoot
+} from "./chunk-CSXLLEGB.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind
+} from "./chunk-V3KLVK7B.js";
+import {
+  listMarkdownFilesRecursiveStrict,
+  readMarkdownFile
+} from "./chunk-352PCJLK.js";
+
+// src/planning/issue-types.ts
+var LeaseExpiredError = class extends Error {
+  constructor(entityId, expiredAt) {
+    super(`Lease expired for ${entityId} at ${expiredAt}`);
+    this.entityId = entityId;
+    this.expiredAt = expiredAt;
+    this.name = "LeaseExpiredError";
+  }
+  entityId;
+  expiredAt;
+};
+var InvalidTransitionError = class extends Error {
+  constructor(entityId, fromStatus, toStatus, reason) {
+    super(
+      `Invalid transition for ${entityId}: ${fromStatus} \u2192 ${toStatus}${reason ? ` (${reason})` : ""}`
+    );
+    this.entityId = entityId;
+    this.fromStatus = fromStatus;
+    this.toStatus = toStatus;
+    this.reason = reason;
+    this.name = "InvalidTransitionError";
+  }
+  entityId;
+  fromStatus;
+  toStatus;
+  reason;
+};
+var HumanReviewRequiredError = class extends Error {
+  constructor(entityId, transition, category, severity) {
+    super(
+      `Human review required for ${entityId}: ${transition} (category=${category}, severity=${severity ?? "n/a"})`
+    );
+    this.entityId = entityId;
+    this.transition = transition;
+    this.category = category;
+    this.severity = severity;
+    this.name = "HumanReviewRequiredError";
+  }
+  entityId;
+  transition;
+  category;
+  severity;
+};
+var DEFAULT_LEASE_TTL_MS = 30 * 60 * 1e3;
+
+// src/planning/sprint-completion-ledger.ts
+import * as path from "path";
+function isMissingPathError(error) {
+  return error?.code === "ENOENT";
+}
+async function loadSprintCompletedTaskIds(sprintId, rootDir = getPlanningRoot()) {
+  if (!sprintId) {
+    return /* @__PURE__ */ new Set();
+  }
+  const readCompleted = async (filePath) => {
+    try {
+      const { frontMatter } = await readMarkdownFile(filePath);
+      const ids = Array.isArray(frontMatter.completedTaskIds) ? frontMatter.completedTaskIds.filter((value) => typeof value === "string") : [];
+      return new Set(ids);
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        return null;
+      }
+      throw error;
+    }
+  };
+  const activePath = path.join(getBucketPathByKind("sprint", rootDir), `${sprintId}.md`);
+  const active = await readCompleted(activePath);
+  if (active) {
+    return active;
+  }
+  const archiveDir = getBucketArchivePathByKind("sprint", rootDir);
+  const archived = await listMarkdownFilesRecursiveStrict(archiveDir);
+  const match = archived.find((filePath) => path.basename(filePath) === `${sprintId}.md`);
+  if (match) {
+    return await readCompleted(match) ?? /* @__PURE__ */ new Set();
+  }
+  return /* @__PURE__ */ new Set();
+}
+
+export {
+  LeaseExpiredError,
+  InvalidTransitionError,
+  HumanReviewRequiredError,
+  DEFAULT_LEASE_TTL_MS,
+  loadSprintCompletedTaskIds
+};
+//# sourceMappingURL=chunk-R5EXHMUN.js.map