@starterculture/devkeep-actions 0.0.1

package/dist/draft-log-entry.js

@@ -0,0 +1,718 @@
+#!/usr/bin/env node
+
+// ../../modules/core/dist/github/client.js
+import { Octokit } from "@octokit/rest";
+function createGithubClient(token) {
+  if (!token) {
+    throw new Error("GitHub token is required");
+  }
+  return new Octokit({ auth: token });
+}
+
+// ../../modules/core/dist/github/retryOnConflict.js
+async function retryOnConflict(attempt, maxAttempts = 3) {
+  for (let tryNumber = 1; ; tryNumber++) {
+    try {
+      return await attempt();
+    } catch (error) {
+      const status = error.status;
+      if (tryNumber >= maxAttempts || status !== 409 && status !== 422) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 300 * tryNumber));
+    }
+  }
+}
+
+// ../../modules/core/dist/tokenUsage.js
+var ZERO_USAGE = { inputTokens: 0, outputTokens: 0 };
+function addTokenUsage(a, b) {
+  return { inputTokens: a.inputTokens + b.inputTokens, outputTokens: a.outputTokens + b.outputTokens };
+}
+
+// ../../modules/core/dist/rollover.js
+var ZERO_ROLLOVER_USAGE = {
+  today: { key: "", usage: ZERO_USAGE },
+  month: { key: "", usage: ZERO_USAGE }
+};
+function todayKey(now = /* @__PURE__ */ new Date()) {
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function monthKey(now = /* @__PURE__ */ new Date()) {
+  return todayKey(now).slice(0, 7);
+}
+function addRolloverUsage(current, delta, now = /* @__PURE__ */ new Date()) {
+  const nowTodayKey = todayKey(now);
+  const nowMonthKey = monthKey(now);
+  return {
+    today: {
+      key: nowTodayKey,
+      usage: addTokenUsage(current.today.key === nowTodayKey ? current.today.usage : ZERO_USAGE, delta)
+    },
+    month: {
+      key: nowMonthKey,
+      usage: addTokenUsage(current.month.key === nowMonthKey ? current.month.usage : ZERO_USAGE, delta)
+    }
+  };
+}
+
+// ../../modules/core/dist/claude/client.js
+import Anthropic from "@anthropic-ai/sdk";
+function createClaudeClient(apiKey) {
+  const key = apiKey ?? process.env.ANTHROPIC_API_KEY;
+  if (!key) {
+    throw new Error("ANTHROPIC_API_KEY is not set");
+  }
+  return new Anthropic({ apiKey: key });
+}
+
+// ../../modules/core/dist/claude/complete.js
+var DEFAULT_MAX_CONTINUATIONS = 5;
+var CONTINUATION_USER_MESSAGE = "Continue exactly where you left off. Do not repeat any text already written, and do not add any preamble or commentary \u2014 resume the previous response verbatim from the exact cutoff point.";
+async function createCompleteMessage(claude, params, { maxContinuations = DEFAULT_MAX_CONTINUATIONS, timeoutMs, signal } = {}) {
+  let fullText = "";
+  let usage = ZERO_USAGE;
+  const requestOptions = timeoutMs !== void 0 || signal !== void 0 ? { timeout: timeoutMs, signal } : void 0;
+  for (let attempt = 0; attempt <= maxContinuations; attempt++) {
+    const messages = fullText ? [
+      ...params.messages,
+      { role: "assistant", content: fullText },
+      { role: "user", content: CONTINUATION_USER_MESSAGE }
+    ] : params.messages;
+    const message = requestOptions ? await claude.messages.create({ ...params, messages }, requestOptions) : await claude.messages.create({ ...params, messages });
+    const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+    fullText += text;
+    usage = addTokenUsage(usage, {
+      inputTokens: message.usage?.input_tokens ?? 0,
+      outputTokens: message.usage?.output_tokens ?? 0
+    });
+    if (message.stop_reason !== "max_tokens") {
+      return { text: fullText, usage };
+    }
+  }
+  throw new Error(`Claude response still hit max_tokens after ${maxContinuations} continuation attempts \u2014 refusing to return truncated content.`);
+}
+
+// ../../modules/core/dist/modelRegistry.js
+var MODEL_REGISTRY = {
+  fast: {
+    description: "Quick, cheap work where depth matters least.",
+    models: [{ id: "claude-haiku-4-5-20251001", label: "Haiku 4.5" }]
+  },
+  balanced: {
+    description: "The everyday tier: chat, log entries, release notes, the daily digest. Frequent enough that cost matters.",
+    models: [{ id: "claude-sonnet-5", label: "Sonnet 5" }]
+  },
+  capable: {
+    description: "Deeper reasoning for infrequent, high-value work where getting it right outweighs the cost.",
+    models: [{ id: "claude-opus-5", label: "Opus 5" }]
+  },
+  max: {
+    description: "Maximum depth, for long-running agentic work. Opt-in \u2014 the most expensive tier.",
+    models: [{ id: "claude-fable-5", label: "Fable 5" }]
+  }
+};
+function defaultModelFor(tier) {
+  const [current] = MODEL_REGISTRY[tier].models;
+  if (!current) {
+    throw new Error(`Model tier "${tier}" has no models registered`);
+  }
+  return current.id;
+}
+
+// ../../modules/devlore/dist/ciUsage.js
+var EMPTY_PROJECT_USAGE = {
+  draftLogEntry: ZERO_USAGE,
+  consolidateRelease: ZERO_USAGE,
+  syncUserManual: ZERO_USAGE,
+  rollover: ZERO_ROLLOVER_USAGE
+};
+function usagePath(projectName) {
+  return `projects/${projectName}/usage.json`;
+}
+async function getUsageFile(octokit, { owner, repo, projectName }) {
+  try {
+    const { data } = await octokit.rest.repos.getContent({
+      owner,
+      repo,
+      path: usagePath(projectName)
+    });
+    if (Array.isArray(data) || data.type !== "file") {
+      return { usage: EMPTY_PROJECT_USAGE };
+    }
+    const parsed = JSON.parse(Buffer.from(data.content, "base64").toString("utf-8"));
+    const usage = { ...EMPTY_PROJECT_USAGE, ...parsed };
+    return { usage, sha: data.sha };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return { usage: EMPTY_PROJECT_USAGE };
+    }
+    throw error;
+  }
+}
+function addUsage(current, source, delta, now = /* @__PURE__ */ new Date()) {
+  return {
+    ...current,
+    [source]: addTokenUsage(current[source], delta),
+    rollover: addRolloverUsage(current.rollover, delta, now)
+  };
+}
+async function recordUsage(octokit, params, source, delta, now = /* @__PURE__ */ new Date()) {
+  const { owner, repo, projectName, branch } = params;
+  await retryOnConflict(async () => {
+    const { usage: current, sha } = await getUsageFile(octokit, { owner, repo, projectName });
+    const updated = addUsage(current, source, delta, now);
+    await octokit.rest.repos.createOrUpdateFileContents({
+      owner,
+      repo,
+      path: usagePath(projectName),
+      message: `Record ${source} token usage: ${projectName}`,
+      content: Buffer.from(JSON.stringify(updated, null, 2), "utf-8").toString("base64"),
+      branch,
+      sha
+    });
+  });
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "status" in error && error.status === 404;
+}
+
+// ../../modules/devlore/dist/decisionEntries.js
+function decisionEntriesDir(projectName) {
+  return `projects/${projectName}/decisions`;
+}
+function decisionEntryPath(projectName, commitSha, moduleId) {
+  const filename = moduleId ? `${commitSha}-${moduleId}.md` : `${commitSha}.md`;
+  return `${decisionEntriesDir(projectName)}/${filename}`;
+}
+var DECISION_MARKER = "<!-- devlore:decision -->";
+function parseLogEntryResponse(text) {
+  const markerIndex = text.indexOf(DECISION_MARKER);
+  if (markerIndex === -1) {
+    return { logEntry: text.trim(), decisionEntry: null };
+  }
+  const logEntry = text.slice(0, markerIndex).trim();
+  const decisionEntry = text.slice(markerIndex + DECISION_MARKER.length).trim();
+  return { logEntry, decisionEntry: decisionEntry || null };
+}
+
+// ../../modules/devlore/dist/diff.js
+function toDiffFile(file) {
+  return {
+    filename: file.filename,
+    status: file.status,
+    patch: file.patch ?? "(no patch available)"
+  };
+}
+async function getProjectDiff(octokit, { owner, repo, base, head }) {
+  try {
+    const { data } = await octokit.rest.repos.compareCommitsWithBasehead({
+      owner,
+      repo,
+      basehead: `${base}...${head}`
+    });
+    return {
+      commitMessages: data.commits.map((commit) => commit.commit.message),
+      files: (data.files ?? []).map(toDiffFile)
+    };
+  } catch {
+    const { data } = await octokit.rest.repos.getCommit({ owner, repo, ref: head });
+    return {
+      commitMessages: [data.commit.message],
+      files: (data.files ?? []).map(toDiffFile)
+    };
+  }
+}
+
+// ../../modules/devlore/dist/masterDocs.js
+function masterDocsPath(projectName) {
+  return `projects/${projectName}/master/README.md`;
+}
+async function getMasterDocs(octokit, params) {
+  return (await getMasterDocsFile(octokit, params)).content;
+}
+async function getMasterDocsFile(octokit, { owner, repo, projectName }) {
+  try {
+    const { data } = await octokit.rest.repos.getContent({
+      owner,
+      repo,
+      path: masterDocsPath(projectName)
+    });
+    if (Array.isArray(data) || data.type !== "file") {
+      return { content: "" };
+    }
+    return { content: Buffer.from(data.content, "base64").toString("utf-8"), sha: data.sha };
+  } catch (error) {
+    if (isNotFound2(error)) {
+      return { content: "" };
+    }
+    throw error;
+  }
+}
+function isNotFound2(error) {
+  return typeof error === "object" && error !== null && "status" in error && error.status === 404;
+}
+
+// ../../modules/devlore/dist/modules.js
+var MODULES_MANIFEST_PATH = "docs/MODULES.md";
+function parseModulesManifest(yamlText) {
+  const lines = yamlText.split("\n");
+  let shellProductDoc = null;
+  let shellName = null;
+  const modules = [];
+  let current = null;
+  let inShell = false;
+  function flushCurrent() {
+    if (current && current.id && current.name && current.productDoc) {
+      modules.push(current);
+    }
+  }
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/#.*$/, "").trimEnd();
+    if (!line.trim())
+      continue;
+    if (/^shell:\s*$/.test(line)) {
+      inShell = true;
+      continue;
+    }
+    if (/^modules:\s*$/.test(line)) {
+      inShell = false;
+      continue;
+    }
+    if (inShell) {
+      const productDocMatch2 = line.match(/^\s+productDoc:\s*(.+)$/);
+      if (productDocMatch2)
+        shellProductDoc = productDocMatch2[1].trim();
+      const nameMatch2 = line.match(/^\s+name:\s*(.+)$/);
+      if (nameMatch2)
+        shellName = nameMatch2[1].trim();
+      continue;
+    }
+    const itemStart = line.match(/^\s*-\s*id:\s*(.+)$/);
+    if (itemStart) {
+      flushCurrent();
+      current = { id: itemStart[1].trim() };
+      continue;
+    }
+    const nameMatch = line.match(/^\s+name:\s*(.+)$/);
+    if (nameMatch && current) {
+      current.name = nameMatch[1].trim();
+      continue;
+    }
+    const productDocMatch = line.match(/^\s+productDoc:\s*(.+)$/);
+    if (productDocMatch && current) {
+      current.productDoc = productDocMatch[1].trim();
+      continue;
+    }
+  }
+  flushCurrent();
+  if (!shellProductDoc) {
+    return null;
+  }
+  return { shell: { productDoc: shellProductDoc, ...shellName ? { name: shellName } : {} }, modules };
+}
+async function readModulesManifest(octokit, { owner, repo, ref }) {
+  try {
+    const { data } = await octokit.rest.repos.getContent({
+      owner,
+      repo,
+      path: MODULES_MANIFEST_PATH,
+      ref
+    });
+    if (Array.isArray(data) || data.type !== "file") {
+      return null;
+    }
+    const text = Buffer.from(data.content, "base64").toString("utf-8");
+    return parseModulesManifest(text);
+  } catch (error) {
+    if (isNotFound3(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function isNotFound3(error) {
+  return typeof error === "object" && error !== null && "status" in error && error.status === 404;
+}
+
+// ../../modules/devlore/dist/prompt.js
+var MAX_DIFF_CHARS = 2e4;
+function buildLogEntryPrompt(input) {
+  const diffText = input.files.map((file) => `--- ${file.filename} (${file.status}) ---
+${file.patch}`).join("\n\n");
+  const diff = diffText.length > MAX_DIFF_CHARS ? `${diffText.slice(0, MAX_DIFF_CHARS)}
+
+[diff truncated]` : diffText;
+  return [
+    `Project: ${input.projectName}`,
+    ...input.moduleName ? [
+      `Module: ${input.moduleName}`,
+      `This diff is only this module's own slice of a larger push that touched more than one module \u2014 draft the log entry scoped to this module alone, not the whole push.`
+    ] : [],
+    `Date: ${input.date}`,
+    "",
+    "Commit messages:",
+    input.commitMessages.map((message) => `- ${message}`).join("\n"),
+    "",
+    "Current master docs (may be empty if none exist yet):",
+    input.masterDocs || "(none yet)",
+    "",
+    "Diff:",
+    diff,
+    "",
+    `Draft a concise log entry in markdown dated ${input.date} covering: what changed, why (infer from the commits/diff), and files touched. This is a draft trail, not the official record \u2014 keep it factual and brief.`,
+    "",
+    "Separately, judge whether this push represents a genuine architectural or strategic DECISION \u2014 not routine work, even important routine work. It counts only if a real fork existed and one path was chosen over real alternatives, in a way that shapes how future work in this area gets done:",
+    "- A technology, architecture, or approach chosen over a real alternative.",
+    "- A previously-taken approach reversed, replaced, or explicitly rejected.",
+    "- A dependency or service adopted or dropped for a stated reason.",
+    "- A cross-cutting convention established that future work is expected to follow.",
+    "",
+    "It does NOT count, even when the change is real and important, if it's:",
+    "- A bug fix, even a significant one \u2014 correcting behavior to match an already-decided design isn't a new decision.",
+    "- A new feature or requirement implemented by following an already-established pattern.",
+    "- A refactor, rename, or reorganization that doesn't change any actual approach.",
+    "- A test, tooling, formatting, or lint fix.",
+    "",
+    `The test to apply: if someone joins this project a year from now and asks "why does it work this way instead of some other way," would this diff be the answer? If the honest answer is "because that's just what implementing the feature required," it isn't a decision. If genuinely borderline, treat it as not a decision.`,
+    "",
+    `If \u2014 and only if \u2014 this push is a real decision by that bar, add this after the log entry, on its own line: ${DECISION_MARKER}`,
+    "Then, below it, write the decision entry in this format:",
+    "",
+    "## <Short decision title>",
+    "**Context:** <what prompted this \u2014 the problem or constraint that made a choice necessary>",
+    "**Decision:** <what was chosen>",
+    "**Alternatives considered:** <other real options and why they weren't chosen \u2014 omit this line entirely if none were genuinely on the table>",
+    "**Consequences:** <what this commits future work to, or rules out>",
+    "",
+    "If this push is not a decision by that bar, do not include the marker or a decision section at all \u2014 just the log entry."
+  ].join("\n");
+}
+
+// ../../modules/devlore/dist/productDoc.js
+var SOURCE_PRODUCT_DOC_PATH = "docs/PRODUCT.md";
+function productDocPath(projectName, moduleId) {
+  return moduleId ? `projects/${projectName}/product-${moduleId}.md` : `projects/${projectName}/product.md`;
+}
+async function getSourceProductDoc(octokit, { owner, repo, ref, path = SOURCE_PRODUCT_DOC_PATH }) {
+  try {
+    const { data } = await octokit.rest.repos.getContent({
+      owner,
+      repo,
+      path,
+      ref
+    });
+    if (Array.isArray(data) || data.type !== "file") {
+      return null;
+    }
+    return Buffer.from(data.content, "base64").toString("utf-8");
+  } catch (error) {
+    if (isNotFound4(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function getVaultProductDoc(octokit, { owner, repo, projectName, moduleId }) {
+  try {
+    const { data } = await octokit.rest.repos.getContent({
+      owner,
+      repo,
+      path: productDocPath(projectName, moduleId)
+    });
+    if (Array.isArray(data) || data.type !== "file") {
+      return { content: "" };
+    }
+    return { content: Buffer.from(data.content, "base64").toString("utf-8"), sha: data.sha };
+  } catch (error) {
+    if (isNotFound4(error)) {
+      return { content: "" };
+    }
+    throw error;
+  }
+}
+function isNotFound4(error) {
+  return typeof error === "object" && error !== null && "status" in error && error.status === 404;
+}
+
+// ../../modules/devlore/dist/pushRouting.js
+var PRODUCT_DOC_SUFFIX = "/docs/PRODUCT.md";
+function moduleDir(productDocPath2) {
+  return productDocPath2.endsWith(PRODUCT_DOC_SUFFIX) ? productDocPath2.slice(0, -PRODUCT_DOC_SUFFIX.length) : null;
+}
+function routeDiffByModule(files, manifest) {
+  if (!manifest) {
+    return [{ moduleId: null, moduleName: null, productDocPath: "docs/PRODUCT.md", files }];
+  }
+  const candidates = manifest.modules.map((m) => ({ id: m.id, name: m.name, productDoc: m.productDoc, dir: moduleDir(m.productDoc) })).filter((m) => m.dir !== null);
+  const filesByModuleId = /* @__PURE__ */ new Map();
+  const shellFiles = [];
+  for (const file of files) {
+    const match = candidates.find((m) => file.filename === m.dir || file.filename.startsWith(`${m.dir}/`));
+    if (!match) {
+      shellFiles.push(file);
+      continue;
+    }
+    const bucket = filesByModuleId.get(match.id) ?? [];
+    bucket.push(file);
+    filesByModuleId.set(match.id, bucket);
+  }
+  const buckets = [];
+  for (const candidate of candidates) {
+    const bucketFiles = filesByModuleId.get(candidate.id);
+    if (bucketFiles && bucketFiles.length > 0) {
+      buckets.push({ moduleId: candidate.id, moduleName: candidate.name, productDocPath: candidate.productDoc, files: bucketFiles });
+    }
+  }
+  if (shellFiles.length > 0 || buckets.length === 0) {
+    buckets.push({ moduleId: null, moduleName: null, productDocPath: manifest.shell.productDoc, files: shellFiles });
+  }
+  return buckets;
+}
+
+// ../../modules/devlore/dist/redact.js
+var REDACTED = "[REDACTED]";
+var KNOWN_SECRET_PATTERNS = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /gh[pousr]_[A-Za-z0-9]{36,}/g,
+  /github_pat_[A-Za-z0-9_]{20,}/g,
+  /sk-ant-[A-Za-z0-9_-]{20,}/g,
+  /sk-[A-Za-z0-9]{20,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /xox[baprs]-[A-Za-z0-9-]{10,}/g,
+  /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g
+];
+var SECRET_KEYWORD = "(?:API[_-]?KEY|SECRET|TOKEN|PASSWORD|PASSWD|PRIVATE[_-]?KEY|CREDENTIAL)";
+var ASSIGNMENT_PATTERN = new RegExp(`((?:[A-Za-z0-9]+[_-])*${SECRET_KEYWORD}(?:[_-][A-Za-z0-9]+)*\\s*[:=]\\s*)(["']?)([^"'\`\\s]+)\\2`, "gi");
+var SENSITIVE_FILENAME_PATTERNS = [
+  /(^|\/)\.env(\..+)?$/,
+  /\.pem$/,
+  /\.key$/,
+  /\.p12$/,
+  /\.pfx$/,
+  /(^|\/)id_rsa(\.pub)?$/,
+  /(^|\/)id_ed25519(\.pub)?$/,
+  /credentials\.json$/,
+  /secrets?\.(json|ya?ml|toml)$/
+];
+function redactText(text) {
+  let result = text;
+  for (const pattern of KNOWN_SECRET_PATTERNS) {
+    result = result.replace(pattern, REDACTED);
+  }
+  result = result.replace(ASSIGNMENT_PATTERN, (_match, prefix, quote) => `${prefix}${quote}${REDACTED}${quote}`);
+  return result;
+}
+function isSensitiveFilename(filename) {
+  return SENSITIVE_FILENAME_PATTERNS.some((pattern) => pattern.test(filename));
+}
+function redactDiffFile(file) {
+  if (isSensitiveFilename(file.filename)) {
+    return { ...file, patch: `(patch redacted: ${file.filename} may contain secrets)` };
+  }
+  return { ...file, patch: redactText(file.patch) };
+}
+function redactProjectDiff(diff) {
+  return {
+    commitMessages: diff.commitMessages.map(redactText),
+    files: diff.files.map(redactDiffFile)
+  };
+}
+
+// ../../modules/devlore/dist/actions/draftLogEntry.js
+var VAULT_BRANCH = "main";
+var MODEL_TIER = "balanced";
+var MAX_TOKENS = 2048;
+function logEntryPath(projectName, commitSha, moduleId) {
+  const filename = moduleId ? `${commitSha}-${moduleId}.md` : `${commitSha}.md`;
+  return `projects/${projectName}/log/${filename}`;
+}
+async function syncProductDoc(projectOctokit, vaultOctokit, { projectOwner, projectRepoName, vaultOwner, vaultRepoName, projectName, headSha, sourceProductDocPath, moduleId }) {
+  const sourceDoc = await getSourceProductDoc(projectOctokit, {
+    owner: projectOwner,
+    repo: projectRepoName,
+    ref: headSha,
+    path: sourceProductDocPath
+  });
+  if (sourceDoc === null) {
+    return;
+  }
+  const redactedDoc = redactText(sourceDoc);
+  await retryOnConflict(async () => {
+    const existing = await getVaultProductDoc(vaultOctokit, {
+      owner: vaultOwner,
+      repo: vaultRepoName,
+      projectName,
+      moduleId
+    });
+    if (existing.content === redactedDoc) {
+      return;
+    }
+    await vaultOctokit.rest.repos.createOrUpdateFileContents({
+      owner: vaultOwner,
+      repo: vaultRepoName,
+      path: productDocPath(projectName, moduleId),
+      message: `Sync PRODUCT.md: ${projectName}@${headSha.slice(0, 7)}`,
+      content: Buffer.from(redactedDoc, "utf-8").toString("base64"),
+      branch: VAULT_BRANCH,
+      sha: existing.sha
+    });
+  });
+}
+async function draftBucketLogEntry({ vaultOctokit, claude, vaultOwner, vaultRepoName, projectName, headSha, date, commitMessages, files, masterDocs, moduleId, moduleName }) {
+  const prompt = buildLogEntryPrompt({
+    projectName,
+    date,
+    commitMessages,
+    files,
+    masterDocs,
+    moduleName: moduleName ?? void 0
+  });
+  const { text, usage } = await createCompleteMessage(claude, {
+    model: defaultModelFor(MODEL_TIER),
+    max_tokens: MAX_TOKENS,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const { logEntry: entryBody, decisionEntry } = parseLogEntryResponse(text);
+  const shortSha = headSha.slice(0, 7);
+  const entryTitle = moduleName ? `${projectName} (${moduleName}) \u2014 ${shortSha}` : `${projectName} \u2014 ${shortSha}`;
+  const entryContent = `# ${entryTitle}
+
+${entryBody}
+`;
+  const entryPath = logEntryPath(projectName, headSha, moduleId ?? void 0);
+  await retryOnConflict(() => vaultOctokit.rest.repos.createOrUpdateFileContents({
+    owner: vaultOwner,
+    repo: vaultRepoName,
+    path: entryPath,
+    message: `Draft log entry: ${projectName}@${shortSha}${moduleName ? ` (${moduleName})` : ""}`,
+    content: Buffer.from(entryContent, "utf-8").toString("base64"),
+    branch: VAULT_BRANCH
+  }));
+  let decisionPath = null;
+  if (decisionEntry) {
+    decisionPath = decisionEntryPath(projectName, headSha, moduleId ?? void 0);
+    const decisionContent = `# ${entryTitle}
+
+${decisionEntry}
+`;
+    await retryOnConflict(() => vaultOctokit.rest.repos.createOrUpdateFileContents({
+      owner: vaultOwner,
+      repo: vaultRepoName,
+      path: decisionPath,
+      message: `Draft decision entry: ${projectName}@${shortSha}${moduleName ? ` (${moduleName})` : ""}`,
+      content: Buffer.from(decisionContent, "utf-8").toString("base64"),
+      branch: VAULT_BRANCH
+    }));
+  }
+  return { moduleId, logEntryPath: entryPath, decisionEntryPath: decisionPath, usage };
+}
+async function draftLogEntry({ projectOctokit, vaultOctokit, claude, projectOwner, projectRepoName, vaultOwner, vaultRepoName, projectName, baseSha, headSha }) {
+  const diff = redactProjectDiff(await getProjectDiff(projectOctokit, {
+    owner: projectOwner,
+    repo: projectRepoName,
+    base: baseSha,
+    head: headSha
+  }));
+  const manifest = await readModulesManifest(projectOctokit, {
+    owner: projectOwner,
+    repo: projectRepoName,
+    ref: headSha
+  });
+  const buckets = routeDiffByModule(diff.files, manifest);
+  const masterDocs = await getMasterDocs(vaultOctokit, {
+    owner: vaultOwner,
+    repo: vaultRepoName,
+    projectName
+  });
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const results = [];
+  for (const bucket of buckets) {
+    const result = await draftBucketLogEntry({
+      vaultOctokit,
+      claude,
+      vaultOwner,
+      vaultRepoName,
+      projectName,
+      headSha,
+      date,
+      commitMessages: diff.commitMessages,
+      files: bucket.files,
+      masterDocs,
+      moduleId: bucket.moduleId,
+      moduleName: bucket.moduleName
+    });
+    results.push(result);
+    await syncProductDoc(projectOctokit, vaultOctokit, {
+      projectOwner,
+      projectRepoName,
+      vaultOwner,
+      vaultRepoName,
+      projectName,
+      headSha,
+      sourceProductDocPath: bucket.productDocPath,
+      moduleId: bucket.moduleId ?? void 0
+    });
+  }
+  const totalUsage = results.reduce((total, r) => addTokenUsage(total, r.usage), ZERO_USAGE);
+  await recordUsage(vaultOctokit, { owner: vaultOwner, repo: vaultRepoName, projectName, branch: VAULT_BRANCH }, "draftLogEntry", totalUsage);
+  return results;
+}
+
+// ../../modules/devlore/dist/bin/draftLogEntryCli.js
+function requireEnv(env, name) {
+  const value = env[name];
+  if (!value) {
+    throw new Error(`${name} is not set`);
+  }
+  return value;
+}
+var defaultDeps = {
+  env: process.env,
+  draftLogEntry,
+  createGithubClient,
+  createClaudeClient,
+  log: console.log
+};
+async function main(deps = defaultDeps) {
+  const { env } = deps;
+  const projectName = requireEnv(env, "PROJECT_NAME");
+  const [projectOwner, projectRepoName] = requireEnv(env, "PROJECT_REPO").split("/");
+  const [vaultOwner, vaultRepoName] = requireEnv(env, "VAULT_REPO").split("/");
+  const baseSha = requireEnv(env, "BASE_SHA");
+  const headSha = requireEnv(env, "HEAD_SHA");
+  const projectOctokit = deps.createGithubClient(requireEnv(env, "GITHUB_TOKEN"));
+  const vaultOctokit = deps.createGithubClient(requireEnv(env, "DEVKEEP_GITHUB_TOKEN"));
+  const claude = deps.createClaudeClient(requireEnv(env, "ANTHROPIC_API_KEY"));
+  const results = await deps.draftLogEntry({
+    projectOctokit,
+    vaultOctokit,
+    claude,
+    projectOwner,
+    projectRepoName,
+    vaultOwner,
+    vaultRepoName,
+    projectName,
+    baseSha,
+    headSha
+  });
+  for (const result of results) {
+    deps.log(`Drafted log entry: ${result.logEntryPath}`);
+    if (result.decisionEntryPath) {
+      deps.log(`Drafted decision entry: ${result.decisionEntryPath}`);
+    }
+  }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+export {
+  main,
+  requireEnv
+};