claude-code-session-manager 0.38.7 → 0.39.1

package/src/main/lib/prdLocations.cjs

@@ -0,0 +1,46 @@
+/**
+ * prdLocations.cjs — resolves per-project PRD-source directories.
+ *
+ * PRD 808 (1 of the 808→809→810→811 chain moving PRD storage out of the
+ * single global `~/.claude/session-manager/scheduled-plans/prds/` into each
+ * active project's own `<cwd>/session-manager-operations/scheduler/prds/`,
+ * for consistency with how feedback and HUMAN_LEARN already scope
+ * per-project operational state under `session-manager-operations/`.
+ *
+ * Global scheduler bookkeeping (queue.json, history.jsonl, runs/) is
+ * untouched by this module — it only resolves where PRD *source* .md files
+ * live. Active-project discovery reuses activeSessions.cjs's
+ * activeProjectCwds (the same discovery watchdogHelpers.cjs's sweep() uses)
+ * rather than re-implementing transcript scanning here.
+ */
+'use strict';
+
+const path = require('node:path');
+const { activeProjectCwds } = require('../../../scripts/lib/activeSessions.cjs');
+
+const PRD_SUBPATH = ['session-manager-operations', 'scheduler', 'prds'];
+
+/**
+ * resolvePrdWriteDir(cwd) → `<cwd>/session-manager-operations/scheduler/prds`
+ * Pure path join, no I/O. Throws on a missing/non-string cwd so a caller
+ * never silently resolves a project-scoped path against `undefined`.
+ */
+function resolvePrdWriteDir(cwd) {
+  if (!cwd || typeof cwd !== 'string') {
+    throw new Error('resolvePrdWriteDir: cwd is required');
+  }
+  return path.join(cwd, ...PRD_SUBPATH);
+}
+
+/**
+ * resolvePrdsDirs(maxAgeMin?, opts?) → string[]
+ * One `<cwd>/session-manager-operations/scheduler/prds` dir per active
+ * project cwd (activeProjectCwds' default window is 90 minutes). `opts` is
+ * forwarded to activeProjectCwds (e.g. `projectsDir` override for tests).
+ */
+function resolvePrdsDirs(maxAgeMin, opts) {
+  const cwds = activeProjectCwds(maxAgeMin, opts);
+  return cwds.map(resolvePrdWriteDir);
+}
+
+module.exports = { resolvePrdWriteDir, resolvePrdsDirs, PRD_SUBPATH };

package/src/main/lib/prdMigration.cjs

@@ -0,0 +1,83 @@
+/**
+ * prdMigration.cjs — one-time, idempotent move of PRD source .md files out
+ * of the legacy global `~/.claude/session-manager/scheduled-plans/prds/`
+ * into each PRD's own project's `<cwd>/session-manager-operations/scheduler/prds/`
+ * (PRD 808, first of the 808→809→810→811 chain).
+ *
+ * Idempotent: once a file has been moved out of legacyPrdsDir it is simply
+ * absent on the next run — nothing left to move, so a repeat run is a
+ * no-op fs.readdir + early return. Files whose frontmatter has no parseable
+ * `cwd` are left in place (never silently dropped) and reported back as
+ * `strandedCount` so the caller can log a warning — see `migratePrds`'s
+ * `unresolved` return field, surfaced by scheduler.cjs's boot safety-net.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const { splitFrontmatter } = require('./prdFrontmatter.cjs');
+const { resolvePrdWriteDir } = require('./prdLocations.cjs');
+
+/**
+ * Move every `.md` file in legacyPrdsDir whose frontmatter `cwd` resolves to
+ * an on-disk directory into that project's PRDs dir (renamed, not copied).
+ * Files with missing/unparseable/non-existent `cwd` are left untouched.
+ *
+ * Returns { moved, skipped, unresolved } where:
+ *   - moved: number of files successfully relocated
+ *   - skipped: number of files already gone (race with a concurrent mover)
+ *   - unresolved: [{ file, reason }] for every .md left behind in legacyPrdsDir
+ */
+async function migratePrds(legacyPrdsDir) {
+  let entries;
+  try {
+    entries = await fsp.readdir(legacyPrdsDir);
+  } catch {
+    return { moved: 0, skipped: 0, unresolved: [] };
+  }
+
+  let moved = 0;
+  let skipped = 0;
+  const unresolved = [];
+
+  for (const name of entries) {
+    if (!name.endsWith('.md') || name.startsWith('.')) continue;
+    const src = path.join(legacyPrdsDir, name);
+
+    let raw;
+    try {
+      raw = await fsp.readFile(src, 'utf8');
+    } catch (e) {
+      if (e?.code === 'ENOENT') { skipped++; continue; }
+      unresolved.push({ file: name, reason: `read failed: ${e?.message}` });
+      continue;
+    }
+
+    const { fm } = splitFrontmatter(raw);
+    const cwd = fm.cwd && fm.cwd.trim();
+    if (!cwd) {
+      unresolved.push({ file: name, reason: 'no cwd in frontmatter' });
+      continue;
+    }
+    if (!fs.existsSync(cwd)) {
+      unresolved.push({ file: name, reason: `cwd does not exist on disk: ${cwd}` });
+      continue;
+    }
+
+    const destDir = resolvePrdWriteDir(cwd);
+    const dst = path.join(destDir, name);
+    try {
+      await fsp.mkdir(destDir, { recursive: true });
+      await fsp.rename(src, dst);
+      moved++;
+    } catch (e) {
+      if (e?.code === 'ENOENT') { skipped++; continue; }
+      unresolved.push({ file: name, reason: `move failed: ${e?.message}` });
+    }
+  }
+
+  return { moved, skipped, unresolved };
+}
+
+module.exports = { migratePrds };

package/src/main/lib/rcaFeedbackHook.cjs

@@ -30,8 +30,7 @@ const path = require('node:path');
 const config = require('../config.cjs');
 const { splitFrontmatter } = require('./prdFrontmatter.cjs');
 const { readTail } = require('./fileTail.cjs');
-
-const PRDS_DIR = path.join(os.homedir(), '.claude', 'session-manager', 'scheduled-plans', 'prds');
+const { resolvePrdWriteDir } = require('./prdLocations.cjs');
 
 // The one project this hook always knows how to reach, used as the fallback
 // destination when a job's own cwd has no feedback inbox.
@@ -214,9 +213,10 @@ function readRunMeta(runDir, slug) {
   }
 }
 
-function readPrdBody(slug) {
+function readPrdBody(cwd, slug) {
+  if (!cwd) return '';
   try {
-    const raw = fs.readFileSync(path.join(PRDS_DIR, `${slug}.md`), 'utf8');
+    const raw = fs.readFileSync(path.join(resolvePrdWriteDir(cwd), `${slug}.md`), 'utf8');
     return splitFrontmatter(raw).body;
   } catch {
     return '';
@@ -311,7 +311,7 @@ async function fileRcaFeedback({ job, runDir, verdict, annotations, investigatio
     const meta = readRunMeta(runDir, job.slug);
     const logPath = runDir ? path.join(runDir, `${job.slug}.log`) : null;
     const logTail = logPath ? readTail(logPath, 64 * 1024) : '';
-    const acText = extractAcceptanceCriteria(readPrdBody(job.slug));
+    const acText = extractAcceptanceCriteria(readPrdBody(job.cwd, job.slug));
     const failureClass = classifyFailure({ verdict, logTail });
 
     const markdown = buildRcaMarkdown({

package/src/main/queueOps.cjs

@@ -128,6 +128,27 @@ const INTERACTIVE_AC_PATTERNS = [
 ];
 
 const { splitFrontmatter } = require('./lib/prdFrontmatter.cjs');
+const { resolvePrdsDirs } = require('./lib/prdLocations.cjs');
+
+// PRD 808: PRDS_DIR is now the LEGACY global dir — kept as a migration
+// source and search fallback for not-yet-migrated files. Live PRDs resolve
+// per-project via prdLocations.cjs's resolvePrdsDirs(). candidatePrdsDirs()
+// aggregates both so the linter/archive/retag operations still see every
+// PRD regardless of which dir it currently lives in.
+function candidatePrdsDirs() {
+  return [PRDS_DIR, ...resolvePrdsDirs()];
+}
+
+/** Search every candidate PRD dir for `<slug>.md`; returns the containing dir or null. */
+async function findPrdDir(slug) {
+  for (const dir of candidatePrdsDirs()) {
+    try {
+      await fsp.access(path.join(dir, `${slug}.md`));
+      return dir;
+    } catch { /* not here — try the next candidate dir */ }
+  }
+  return null;
+}
 
 /**
  * Lint a single PRD asynchronously. Returns { slug, findings: [...] }.
@@ -237,16 +258,18 @@ function lintParsed(slug, raw) {
  * so Promise.all never rejects under normal use.
  */
 async function lintAll() {
-  let entries = [];
-  try {
-    entries = await fsp.readdir(PRDS_DIR);
-  } catch {
-    return { reports: [], scannedAt: Date.now() };
-  }
   const paths = [];
-  for (const name of entries) {
-    if (!name.endsWith('.md') || name.startsWith('.')) continue;
-    paths.push(path.join(PRDS_DIR, name));
+  for (const dir of candidatePrdsDirs()) {
+    let entries;
+    try {
+      entries = await fsp.readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (!name.endsWith('.md') || name.startsWith('.')) continue;
+      paths.push(path.join(dir, name));
+    }
   }
   const reports = await Promise.all(paths.map(async (filePath) => {
     try {
@@ -270,8 +293,10 @@ async function lintAll() {
  */
 async function archiveOne(slug, archiveDir) {
   if (!SLUG_RE.test(slug)) return { ok: false, slug, error: 'invalid slug' };
-  const src = path.resolve(path.join(PRDS_DIR, `${slug}.md`));
-  if (!src.startsWith(PRDS_DIR + path.sep)) return { ok: false, slug, error: 'path escape (src)' };
+  const srcDir = await findPrdDir(slug);
+  if (!srcDir) return { ok: false, slug, error: 'not found in any PRDs dir' };
+  const src = path.resolve(path.join(srcDir, `${slug}.md`));
+  if (!src.startsWith(srcDir + path.sep)) return { ok: false, slug, error: 'path escape (src)' };
   const dst = path.resolve(path.join(archiveDir, `${slug}.md`));
   if (!dst.startsWith(PRDS_ARCHIVE_DIR + path.sep)) return { ok: false, slug, error: 'path escape (dst)' };
   try {
@@ -407,8 +432,10 @@ async function autoArchiveCompleted(state, { nowMs } = {}) {
  */
 async function retagOne({ slug, parallelGroup, estimateMinutes }) {
   if (!SLUG_RE.test(slug)) return { ok: false, slug, error: 'invalid slug' };
-  const src = path.resolve(path.join(PRDS_DIR, `${slug}.md`));
-  if (!src.startsWith(PRDS_DIR + path.sep)) return { ok: false, slug, error: 'path escape' };
+  const dir = await findPrdDir(slug);
+  if (!dir) return { ok: false, slug, error: 'not found in any PRDs dir' };
+  const src = path.resolve(path.join(dir, `${slug}.md`));
+  if (!src.startsWith(dir + path.sep)) return { ok: false, slug, error: 'path escape' };
 
   let raw;
   try {
@@ -470,8 +497,8 @@ async function retagOne({ slug, parallelGroup, estimateMinutes }) {
     }
     if (!SLUG_RE.test(newSlug)) return { ok: false, slug, error: 'new slug would be invalid' };
   }
-  const dst = path.resolve(path.join(PRDS_DIR, `${newSlug}.md`));
-  if (!dst.startsWith(PRDS_DIR + path.sep)) return { ok: false, slug, error: 'new path escape' };
+  const dst = path.resolve(path.join(dir, `${newSlug}.md`));
+  if (!dst.startsWith(dir + path.sep)) return { ok: false, slug, error: 'new path escape' };
 
   // Atomic write via shared helper. If slug changed, write at the new path
   // and unlink the old slug.
@@ -551,4 +578,6 @@ module.exports = {
   retagMany,
   PRDS_DIR,
   PRDS_ARCHIVE_DIR,
+  candidatePrdsDirs,
+  findPrdDir,
 };