@natjswenson/devlog 0.9.0 → 0.11.0

package/lib/scan.mjs

@@ -66,10 +66,11 @@ function git(projectPath, args) {
   return execArgs('git', ['-C', projectPath, ...args]);
 }
 
-// Scan one project's local clone. Pure git — the caller supplies the set of
-// entry filenames that already exist in the target repo (existingFiles), so
-// this function stays testable against throwaway fixture repos.
-export function scanProject(project, { branch = 'main', fetch = true, existingFiles = new Set() } = {}) {
+// Scan one project's local clone. Pure git — the caller supplies what already
+// exists in the target repo (`existing`: entry filenames, live manifest
+// versions, and tombstoned versions), so this function stays testable against
+// throwaway fixture repos.
+export function scanProject(project, { branch = 'main', fetch = true, existing = emptyExisting() } = {}) {
   const out = {
     key: project.key,
     label: project.label || project.key,
@@ -119,7 +120,14 @@ export function scanProject(project, { branch = 'main', fetch = true, existingFi
 
   for (let i = 0; i < releases.length; i++) {
     const { tag, version } = releases[i];
-    if (existingFiles.has(`${version}.md`)) {
+    // Tombstone check comes first: a tombstoned row also carries a `file`
+    // field, so the entry-exists check below would otherwise mask the more
+    // specific reason.
+    if (existing.removedVersions.has(version)) {
+      out.skippedTags.push({ tag, reason: 'entry-tombstoned' });
+      continue;
+    }
+    if (existing.versions.has(version) || existing.files.has(`${version}.md`)) {
       out.skippedTags.push({ tag, reason: 'entry-exists' });
       continue;
     }
@@ -185,21 +193,65 @@ function splitLogLine(line) {
   return [hash, subject, date];
 }
 
-// Which entry files already exist in the target repo for one project — a
-// single `gh api` directory listing (vs. the old one-probe-per-tag pattern).
-// Returns { files: Set, status: 'ok' | 'empty' | 'failed' }: a 404 means the
-// project has no entries yet; any other failure is surfaced so the caller
-// knows the entry-exists filter may be incomplete (publish-entry still refuses
-// overwrites against the fresh clone, so a stale scan cannot clobber anything).
-export function fetchExistingEntries(targetRepo, branch, projectKey) {
-  const r = spawnArgs('gh', ['api', `repos/${targetRepo}/contents/${projectKey}?ref=${branch}`, '--jq', '.[].name']);
+export function emptyExisting() {
+  return { files: new Set(), versions: new Set(), removedVersions: new Set(), entries: [] };
+}
+
+// What already exists in the target repo for one project. Entry identity is
+// project+version in the MANIFEST, not a filename: manifest rows survive
+// editorial file moves/consolidations, and a tombstoned row (`removed: true`)
+// keeps suppressing generation even after its .md is gone — the failure class
+// that re-armed three deleted entries in the first six runs. Fetches the
+// project's manifest.json (one `gh api` call); falls back to a directory
+// listing for legacy dirs with entries but no manifest yet.
+// Returns { files: Set, versions: Set, removedVersions: Set,
+//           entries: [{version, title, tags}] (live rows only),
+//           status: 'ok' | 'empty' | 'failed' }: 'empty' means the project has
+// no entries yet; 'failed' is surfaced so the caller knows the entry-exists
+// filter may be incomplete (publish-entry still refuses overwrites against the
+// fresh clone, so a stale scan cannot clobber anything).
+export function fetchExistingEntries(targetRepo, branch, projectKey, targetDir = '') {
+  const contentPath = targetDir ? `${targetDir}/${projectKey}` : projectKey;
+  const m = spawnArgs('gh', ['api', `repos/${targetRepo}/contents/${contentPath}/manifest.json?ref=${branch}`, '--jq', '.content']);
+  if (m.status === 0) {
+    let manifest = null;
+    try {
+      manifest = JSON.parse(Buffer.from(m.stdout.replace(/\s/g, ''), 'base64').toString('utf8'));
+    } catch {
+      // Malformed manifest content — fall through to the directory listing.
+    }
+    if (manifest && Array.isArray(manifest.entries)) {
+      const out = { ...emptyExisting(), status: 'ok' };
+      for (const e of manifest.entries) {
+        if (!e) continue;
+        if (typeof e.file === 'string') out.files.add(e.file);
+        if (typeof e.version !== 'string' || e.version === '') continue;
+        if (e.removed) {
+          out.removedVersions.add(e.version);
+        } else {
+          out.versions.add(e.version);
+          out.entries.push({
+            version: e.version,
+            title: typeof e.title === 'string' ? e.title : null,
+            tags: Array.isArray(e.tags) ? e.tags : [],
+          });
+        }
+      }
+      return out;
+    }
+  } else if (!/HTTP 404|Not Found/i.test(m.stderr)) {
+    return { ...emptyExisting(), status: 'failed' };
+  }
+
+  // No manifest (or unparseable): legacy directory listing.
+  const r = spawnArgs('gh', ['api', `repos/${targetRepo}/contents/${contentPath}?ref=${branch}`, '--jq', '.[].name']);
   if (r.status === 0) {
-    return { files: new Set(r.stdout.split('\n').filter(Boolean)), status: 'ok' };
+    return { ...emptyExisting(), files: new Set(r.stdout.split('\n').filter(Boolean)), status: 'ok' };
   }
   if (/HTTP 404|Not Found/i.test(r.stderr)) {
-    return { files: new Set(), status: 'empty' };
+    return { ...emptyExisting(), status: 'empty' };
   }
-  return { files: new Set(), status: 'failed' };
+  return { ...emptyExisting(), status: 'failed' };
 }
 
 // Full scan across the configured projects. `getExisting` is injectable for
@@ -218,14 +270,23 @@ export function scanAll(config, { projectKey = null, fetch = true, getExisting =
   }
 
   const results = projects.map((project) => {
-    const existing = getExisting(config.targetRepo, branch, project.key);
-    const scanned = scanProject(project, { branch, fetch, existingFiles: existing.files });
+    // Normalized so an injected getExisting returning a partial shape (e.g. a
+    // legacy { files, status } double) can't crash the tombstone checks.
+    const existing = { ...emptyExisting(), status: 'ok', ...getExisting(config.targetRepo, branch, project.key, config.targetDir || '') };
+    const scanned = scanProject(project, { branch, fetch, existing });
     scanned.existenceCheck = existing.status;
+    // Live catalog rows for this project — the skill's topic-dedup input
+    // ("don't re-teach a guide the catalog already covers"), free with the
+    // manifest fetch above.
+    scanned.publishedEntries = existing.entries;
     return scanned;
   });
 
   return {
     targetRepo: config.targetRepo,
+    // Subdirectory of targetRepo holding the content tree ('' = repo root) — the
+    // skill appends it to the publish clone path (`--clone <clone>/<targetDir>`).
+    targetDir: config.targetDir || '',
     branch,
     deepDive: resolveDeepDive(config),
     voicePath: config.voicePath || null,
@@ -233,3 +294,25 @@ export function scanAll(config, { projectKey = null, fetch = true, getExisting =
     totalNewReleases: results.reduce((n, p) => n + p.newReleases.length, 0),
   };
 }
+
+// Compact plan-table view of a scanAll result: per release, drop the commit
+// list and diffstat (the bulky parts) for a commitCount; collapse skippedTags
+// to per-reason counts. publishedEntries stays — it's small and the skill's
+// topic-dedup input. Full detail remains one `scan --project <key>` away.
+export function summarizeScan(result) {
+  if (result.error) return result;
+  return {
+    ...result,
+    projects: result.projects.map((p) => ({
+      ...p,
+      newReleases: p.newReleases.map(({ commits, diffstat, ...release }) => ({
+        ...release,
+        commitCount: commits.length,
+      })),
+      skippedTags: p.skippedTags.reduce((acc, { reason }) => {
+        acc[reason] = (acc[reason] || 0) + 1;
+        return acc;
+      }, {}),
+    })),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@natjswenson/devlog",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Release dev log generator \u2014 Claude Code skill + preview app for publishing version-release dev logs, written in your voice, to your site",
   "license": "MIT",
   "author": "Nate Swenson",

package/skill-invariants.json

@@ -81,6 +81,26 @@
       "pattern": "this interactive review IS the quality gate for the cover",
       "rationale": "The rendered cover must be shown to the user before push, the same way Step 4 gates the prose — losing this line reopens publishing an unreviewed cover."
     },
+    {
+      "id": "ground-truth-gate",
+      "pattern": "verify each one with a git command run NOW",
+      "rationale": "The 6-run audit found a post that published a provably false premise about the author's own repo (resume/v1.0.1: 'two of four packages never got tags' — all four existed). Every repo-fact claim must be re-verified against git in-session before publish; losing this line reopens the fabricated-premise path."
+    },
+    {
+      "id": "no-unrun-output",
+      "pattern": "never label output as real[\\s\\S]{0,120}unless the command that produced it ran in\\s+this session",
+      "rationale": "Two audited posts claimed 'real output' over commands that never ran (v0.6.0's phantom fixtures, v0.10.0's internally-impossible scan table). Output honesty must be a hard rule, not a stylistic preference."
+    },
+    {
+      "id": "tombstone-never-republish",
+      "pattern": "editorially retired[\\s\\S]{0,80}skip it silently, never regenerate",
+      "rationale": "Deleted/moved entries re-armed generation three times in the first six runs (ghostwriter v0.8.1 twice, market-research v0.1.0). The tombstoned state must always mean 'never regenerate'."
+    },
+    {
+      "id": "one-commit-one-changelog",
+      "pattern": "refuses a draft whose Changelog repeats a commit",
+      "rationale": "Monorepo twin releases shipped identical Changelogs (resume v1.0.1 + ghostwriter v0.8.1); a commit belongs to exactly one post's Changelog and publish-entry enforces it."
+    },
     {
       "id": "cover-custom-illustration",
       "pattern": "cover that just re-renders the title in large text is a failure",
@@ -95,5 +115,5 @@
       "rationale": "The catalog-icon/hero-zone overlap check must stay wired into renderCoverImage() — losing it silently reopens the gap where a catalog icon (or two, connected by a line) can stand in for the required bespoke hero illustration."
     }
   ],
-  "cli_commands_referenced": ["scan", "lint-post", "publish-entry", "add-project", "remove-project", "set", "config", "init", "cover-context", "render-cover"]
+  "cli_commands_referenced": ["scan", "lint-post", "publish-entry", "add-project", "remove-project", "set", "config", "init", "cover-context", "render-cover", "tombstone", "sync-entry", "assemble-post"]
 }