claudenv 1.2.4 → 1.3.0

package/src/hooks-gen.js

@@ -4,14 +4,36 @@
 
 import { CREDENTIAL_PATHS } from './profiles.js';
 
+/**
+ * Detect whether `claudenv` is on PATH globally. Used to decide whether
+ * settings.json hooks should call `claudenv hook ...` directly or via `npx`.
+ *
+ * Async — but settings generation is sync today. We call this from the
+ * installer flow where we await it, then pass the resolved value in.
+ */
+export async function isGlobalInstall() {
+  try {
+    const { execFile } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const exec = promisify(execFile);
+    await exec('which', ['claudenv']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Generate .claude/settings.json content for a given profile.
  * @param {object} profile - Autonomy profile
  * @param {object} detected - Tech stack detection result
+ * @param {object} [opts]
+ * @param {string} [opts.claudenvCmd] - Command prefix for `claudenv hook ...` (e.g., "claudenv" or "npx claudenv")
  * @returns {string} JSON string
  */
-export function generateSettingsJson(profile, detected = {}) {
+export function generateSettingsJson(profile, detected = {}, opts = {}) {
   const settings = {};
+  const claudenvCmd = opts.claudenvCmd || 'claudenv';
 
   if (profile.allowedTools && profile.allowedTools.length > 0) {
     settings.permissions = settings.permissions || {};
@@ -46,6 +68,16 @@ export function generateSettingsJson(profile, detected = {}) {
     command: 'bash .claude/hooks/audit-log.sh',
     timeout: 10,
   };
+  const decisionsLoggerHook = {
+    type: 'command',
+    command: `${claudenvCmd} hook decisions-logger`,
+    timeout: 5,
+  };
+  const regenIndexHook = {
+    type: 'command',
+    command: `${claudenvCmd} hook regen-index`,
+    timeout: 5,
+  };
 
   settings.hooks = {
     PreToolUse: [
@@ -71,6 +103,16 @@ export function generateSettingsJson(profile, detected = {}) {
         matcher: '',
         hooks: [auditLogHook],
       },
+      {
+        matcher: 'Write',
+        hooks: [decisionsLoggerHook],
+      },
+    ],
+    SessionEnd: [
+      {
+        matcher: '.*',
+        hooks: [regenIndexHook],
+      },
     ],
   };
 
@@ -101,11 +143,21 @@ export function generatePreToolUseHook(profile, detected = {}) {
   return `#!/usr/bin/env bash
 # Pre-tool-use hook — generated by claudenv autonomy (profile: ${profile.name})
 # Exit 0 = allow, Exit 2 = block
+# Claude Code sends hook data via stdin as JSON: {"tool_name":"...","tool_input":{...}}
 
 set -euo pipefail
 
-TOOL_NAME="\${CLAUDE_TOOL_NAME:-}"
-TOOL_INPUT="\${CLAUDE_TOOL_INPUT:-}"
+# Read hook input from stdin (Claude Code sends JSON)
+HOOK_INPUT=$(cat)
+TOOL_NAME=$(echo "$HOOK_INPUT" | sed -n 's/.*"tool_name":"\\([^"]*\\)".*/\\1/p')
+
+# Extract actionable string based on tool type
+# Uses [^"]* to stop at the first unescaped quote — safely ignores other JSON fields
+if [ "$TOOL_NAME" = "Bash" ]; then
+  TOOL_INPUT=$(echo "$HOOK_INPUT" | sed -n 's/.*"command":"\\([^"]*\\)".*/\\1/p')
+else
+  TOOL_INPUT=$(echo "$HOOK_INPUT" | sed -n 's/.*"file_path":"\\([^"]*\\)".*/\\1/p')
+fi
 
 # === Hard blocks (all profiles) ===
 
@@ -157,11 +209,14 @@ export function generateAuditLogHook() {
   return `#!/usr/bin/env bash
 # Post-tool-use audit hook — generated by claudenv autonomy
 # Logs every tool invocation to .claude/audit-log.jsonl
+# Claude Code sends hook data via stdin as JSON: {"tool_name":"...","tool_input":{...}}
 
 set -uo pipefail
 
-TOOL_NAME="\${CLAUDE_TOOL_NAME:-unknown}"
-TOOL_INPUT="\${CLAUDE_TOOL_INPUT:-}"
+# Read hook input from stdin (Claude Code sends JSON)
+HOOK_INPUT=$(cat)
+TOOL_NAME=$(echo "$HOOK_INPUT" | sed -n 's/.*"tool_name":"\\([^"]*\\)".*/\\1/p')
+TOOL_INPUT=$(echo "$HOOK_INPUT" | sed -n 's/.*"tool_input":\\(.*\\)/\\1/p' | sed 's/}$//')
 SESSION_ID="\${CLAUDE_SESSION_ID:-}"
 
 # Truncate input for logging (max 500 chars)

package/src/installer.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SCAFFOLD_GLOBAL = join(__dirname, '..', 'scaffold', 'global');
+const SCAFFOLD_GLOBAL_CLAUDENV = join(__dirname, '..', 'scaffold', 'global-claudenv');
 
 /**
  * Get the path to ~/.claude/
@@ -13,6 +14,14 @@ function getClaudeHome() {
   return join(homedir(), '.claude');
 }
 
+/**
+ * Get the path to ~/.claudenv/ (separate from ~/.claude/ — holds cross-project
+ * memory, canon, user preferences, and the doctor config).
+ */
+function getClaudenvHome() {
+  return join(homedir(), '.claudenv');
+}
+
 /**
  * Recursively list all files in a directory (relative paths).
  */
@@ -31,20 +40,18 @@ async function listFiles(dir, base = dir) {
 }
 
 /**
- * Install global Claude Code artifacts to ~/.claude/.
- * Copies scaffold/global/.claude/ contents into ~/.claude/.
- *
- * @param {object} [options]
- * @param {boolean} [options.force] - Overwrite existing files
- * @param {string} [options.claudeHome] - Override ~/.claude/ path (for testing)
- * @returns {Promise<{written: string[], skipped: string[]}>}
+ * Copy every file under `sourceBase` into `targetBase`, skipping existing files
+ * unless `force` is set. Returns relative paths of what was written/skipped.
  */
-export async function installGlobal(options = {}) {
-  const { force = false, claudeHome } = options;
-  const targetBase = claudeHome || getClaudeHome();
-  const sourceBase = join(SCAFFOLD_GLOBAL, '.claude');
+async function copyTree(sourceBase, targetBase, { force }) {
+  let files;
+  try {
+    files = await listFiles(sourceBase);
+  } catch (err) {
+    if (err.code === 'ENOENT') return { written: [], skipped: [] };
+    throw err;
+  }
 
-  const files = await listFiles(sourceBase);
   const written = [];
   const skipped = [];
 
@@ -52,7 +59,6 @@ export async function installGlobal(options = {}) {
     const src = join(sourceBase, relPath);
     const dest = join(targetBase, relPath);
 
-    // Check if file exists and skip unless force
     if (!force) {
       try {
         await stat(dest);
@@ -66,7 +72,6 @@ export async function installGlobal(options = {}) {
     await mkdir(dirname(dest), { recursive: true });
     await cp(src, dest);
 
-    // Make .sh files executable
     if (relPath.endsWith('.sh')) {
       const { chmod } = await import('node:fs/promises');
       await chmod(dest, 0o755);
@@ -78,6 +83,36 @@ export async function installGlobal(options = {}) {
   return { written, skipped };
 }
 
+/**
+ * Install global Claude Code artifacts to ~/.claude/ AND ~/.claudenv/.
+ * Copies scaffold/global/.claude/ → ~/.claude/ and scaffold/global-claudenv/ → ~/.claudenv/.
+ *
+ * @param {object} [options]
+ * @param {boolean} [options.force] - Overwrite existing files
+ * @param {string} [options.claudeHome] - Override ~/.claude/ path (for testing)
+ * @param {string} [options.claudenvHome] - Override ~/.claudenv/ path (for testing)
+ * @returns {Promise<{written: string[], skipped: string[], claudenvWritten: string[], claudenvSkipped: string[]}>}
+ */
+export async function installGlobal(options = {}) {
+  const { force = false, claudeHome, claudenvHome } = options;
+  const claudeTarget = claudeHome || getClaudeHome();
+  const claudenvTarget = claudenvHome || getClaudenvHome();
+
+  const claude = await copyTree(join(SCAFFOLD_GLOBAL, '.claude'), claudeTarget, { force });
+  const claudenv = await copyTree(SCAFFOLD_GLOBAL_CLAUDENV, claudenvTarget, { force });
+
+  // Ensure baseline subdirectories exist even when scaffold doesn't carry .gitkeep
+  // (decisions/ is empty by design until vibe-decisions fills it).
+  await mkdir(join(claudenvTarget, 'memories', 'decisions'), { recursive: true });
+
+  return {
+    written: claude.written,
+    skipped: claude.skipped,
+    claudenvWritten: claudenv.written,
+    claudenvSkipped: claudenv.skipped,
+  };
+}
+
 /**
  * Remove global Claude Code artifacts from ~/.claude/.
  *
@@ -92,9 +127,16 @@ export async function uninstallGlobal(options = {}) {
 
   const targets = [
     join(targetBase, 'commands', 'claudenv.md'),
+    join(targetBase, 'commands', 'autonomy.md'),
     join(targetBase, 'commands', 'setup-mcp.md'),
     join(targetBase, 'commands', 'improve.md'),
+    join(targetBase, 'commands', 'deeper.md'),
+    join(targetBase, 'commands', 'why.md'),
+    join(targetBase, 'commands', 'decisions.md'),
+    join(targetBase, 'commands', 'canon.md'),
+    join(targetBase, 'commands', 'just-code.md'),
     join(targetBase, 'skills', 'claudenv'),
+    join(targetBase, 'skills', 'vibe-decisions'),
   ];
 
   for (const target of targets) {

package/src/loop.js

@@ -1,8 +1,23 @@
 import { execSync, spawn } from 'node:child_process';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, appendFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { select } from '@inquirer/prompts';
 import { createWorktree, removeWorktree, mergeWorktree, getCurrentBranch } from './worktree.js';
+import { buildSystemPromptWithMemory } from './memory-context.js';
+import { regenIndex } from './hooks/regen-index.js';
+
+// =============================================
+// Work report helpers
+// =============================================
+
+/**
+ * Append a report event to .claude/work-report.jsonl
+ */
+async function writeReportEvent(cwd, event) {
+  const line = JSON.stringify({ ts: new Date().toISOString(), ...event }) + '\n';
+  await mkdir(join(cwd, '.claude'), { recursive: true });
+  await appendFile(join(cwd, '.claude', 'work-report.jsonl'), line);
+}
 
 // =============================================
 // Pre-flight: check Claude CLI
@@ -38,6 +53,7 @@ export function checkClaudeCli() {
  * @param {string} [options.model] - Model to use
  * @param {number} [options.budget] - Budget cap in USD
  * @param {string} [options.appendSystemPrompt] - Append to system prompt
+ * @param {object} [options.env] - Extra env vars to merge into the child process env
  * @returns {Promise<{ result: string, sessionId: string|null, usage: object|null }>}
  */
 export function spawnClaude(prompt, options = {}) {
@@ -68,16 +84,23 @@ export function spawnClaude(prompt, options = {}) {
 
     const child = spawn('claude', args, {
       cwd: options.cwd || process.cwd(),
-      // stdin=inherit avoids Node.js spawn hang bug, stdout=pipe to capture JSON, stderr=inherit for real-time output
-      stdio: ['inherit', 'pipe', 'inherit'],
+      env: options.env ? { ...process.env, ...options.env } : process.env,
+      // stdin=inherit avoids Node.js spawn hang bug, stdout=pipe to capture JSON, stderr=pipe for rate limit detection
+      stdio: ['inherit', 'pipe', 'pipe'],
     });
 
     let stdout = '';
+    let stderrBuf = '';
 
     child.stdout.on('data', (chunk) => {
       stdout += chunk.toString();
     });
 
+    child.stderr.on('data', (chunk) => {
+      process.stderr.write(chunk); // keep real-time output
+      stderrBuf += chunk.toString();
+    });
+
     child.on('error', (err) => {
       if (err.code === 'ENOENT') {
         reject(new Error('Claude CLI not found. Install it from https://docs.anthropic.com/en/docs/claude-code'));
@@ -88,7 +111,10 @@ export function spawnClaude(prompt, options = {}) {
 
     child.on('close', (code) => {
       if (code !== 0) {
-        reject(new Error(`Claude exited with code ${code}`));
+        const isRateLimit = /rate.?limit|429|overloaded|too many requests/i.test(stderrBuf);
+        const err = new Error(`Claude exited with code ${code}`);
+        err.isRateLimit = isRateLimit;
+        reject(err);
         return;
       }
 
@@ -450,6 +476,8 @@ function printFinalSummary(log) {
  * @param {string} [options.cwd] - Working directory
  * @param {boolean} [options.allowDirty] - Allow dirty git state
  * @param {boolean} [options.worktree] - Run each iteration in an isolated git worktree
+ * @param {number} [options.startIteration] - Resume from this iteration (skip planning)
+ * @param {string} [options.initialSessionId] - Session ID to resume from
  */
 export async function runLoop(options = {}) {
   const cwd = options.cwd || process.cwd();
@@ -480,21 +508,30 @@ export async function runLoop(options = {}) {
   console.log(`\n  Git safety tag: ${gitTag}`);
   console.log(`  Pre-loop commit: ${preLoopCommit}`);
 
-  // --- Initialize loop log ---
+  // --- Initialize loop log (carry over previous data on resume) ---
+  const prevLogData = startIteration > 0 ? await readLoopLog(cwd) : null;
   const log = {
-    started: new Date().toISOString(),
+    started: prevLogData?.started || new Date().toISOString(),
     goal: options.goal || 'General improvement',
-    model: options.model || 'sonnet',
-    gitTag,
-    preLoopCommit,
-    iterations: [],
+    model: options.model || null,
+    gitTag: prevLogData?.gitTag || gitTag,
+    preLoopCommit: prevLogData?.preLoopCommit || preLoopCommit,
+    iterations: prevLogData?.iterations || [],
     completedAt: null,
     stopReason: null,
-    totalIterations: 0,
-    hypotheses: [],
+    totalIterations: prevLogData?.totalIterations || 0,
+    hypotheses: prevLogData?.hypotheses || [],
   };
 
   // --- Shared spawn options ---
+  // appendSystemPrompt now includes:
+  //   - autonomy=law directive (from goal)
+  //   - vibe-decisions loop-mode fragment (so the skill auto-logs without pause)
+  //   - memory briefing (INDEX.md contents) if present
+  // The prompt is stable for the session; the prefix stays cache-friendly.
+  const appendedPrompt = await buildSystemPromptWithMemory(options.goal, {
+    autonomyBuilder: buildAutonomySystemPrompt,
+  });
   const spawnOpts = {
     cwd,
     trust: options.trust || false,
@@ -502,11 +539,17 @@ export async function runLoop(options = {}) {
     maxTurns: options.maxTurns || 30,
     model: options.model,
     budget: options.budget,
-    appendSystemPrompt: options.goal ? buildAutonomySystemPrompt(options.goal) : undefined,
+    appendSystemPrompt: appendedPrompt,
+    // Secondary marker for Python helpers (e.g. claudenv-memory 0.2.x) that
+    // want to detect they're being driven by `claudenv loop`. The PRIMARY
+    // mode signal stays the directive fragment in appendSystemPrompt above —
+    // env alone wouldn't be readable by the markdown skill.
+    env: { CLAUDENV_LOOP: '1' },
   };
 
-  let sessionId = null;
+  let sessionId = options.initialSessionId || null;
   let shuttingDown = false;
+  const startIteration = options.startIteration || 0;
 
   // --- Ctrl+C handling ---
   const sigintHandler = () => {
@@ -521,37 +564,63 @@ export async function runLoop(options = {}) {
   process.on('SIGINT', sigintHandler);
 
   try {
-    // --- Iteration 0: Planning ---
-    console.log('\n  Starting iteration 0 (planning)...\n');
-
-    const planPrompt = buildPlanningPrompt(options.goal);
-    const planResult = await spawnClaude(planPrompt, { ...spawnOpts, sessionId });
-    sessionId = planResult.sessionId || sessionId;
-
-    const planIteration = {
-      number: 0,
-      startedAt: log.started,
-      completedAt: new Date().toISOString(),
-      sessionId,
-      summary: 'Generated improvement plan',
-      commitHash: getCurrentCommit(cwd),
-      usage: planResult.usage,
-    };
-    log.iterations.push(planIteration);
-    printIterationSummary(planIteration);
-    await writeLoopLog(cwd, log);
+    // --- Report: loop start ---
+    await writeReportEvent(cwd, {
+      event: 'loop_start',
+      goal: options.goal || 'General improvement',
+      model: options.model || null,
+      gitTag,
+      resume: startIteration > 0,
+    });
 
-    if (shuttingDown) {
-      log.stopReason = 'interrupted';
-      log.completedAt = new Date().toISOString();
-      log.totalIterations = 0;
+    // --- Iteration 0: Planning (skip if resuming) ---
+    if (startIteration === 0) {
+      console.log('\n  Starting iteration 0 (planning)...\n');
+      await writeReportEvent(cwd, { event: 'iteration_start', iteration: 0, type: 'planning' });
+
+      const planPrompt = buildPlanningPrompt(options.goal);
+      const planResult = await spawnClaude(planPrompt, { ...spawnOpts, sessionId });
+      sessionId = planResult.sessionId || sessionId;
+
+      const planIteration = {
+        number: 0,
+        startedAt: log.started,
+        completedAt: new Date().toISOString(),
+        sessionId,
+        summary: 'Generated improvement plan',
+        commitHash: getCurrentCommit(cwd),
+        usage: planResult.usage,
+      };
+      log.iterations.push(planIteration);
+      printIterationSummary(planIteration);
       await writeLoopLog(cwd, log);
-      printFinalSummary(log);
-      return;
+      await writeReportEvent(cwd, {
+        event: 'iteration_end',
+        iteration: 0,
+        summary: 'Generated improvement plan',
+        commitHash: planIteration.commitHash,
+        tokens: planResult.usage ? { in: planResult.usage.input_tokens, out: planResult.usage.output_tokens } : null,
+      });
+
+      // Fallback for SessionEnd hook — regen INDEX.md so the next iteration's
+      // briefing reflects anything written during planning.
+      try { await regenIndex({ cwd }); } catch { /* best-effort */ }
+
+      if (shuttingDown) {
+        log.stopReason = 'interrupted';
+        log.completedAt = new Date().toISOString();
+        log.totalIterations = 0;
+        await writeLoopLog(cwd, log);
+        printFinalSummary(log);
+        return;
+      }
+    } else {
+      console.log(`\n  Resuming from iteration ${startIteration}...\n`);
     }
 
-    // --- Execution iterations 1-N ---
-    for (let i = 1; i <= maxIterations; i++) {
+    // --- Execution iterations 1-N (or startIteration-N if resuming) ---
+    const firstIter = startIteration > 0 ? startIteration : 1;
+    for (let i = firstIter; i <= maxIterations; i++) {
       if (shuttingDown) break;
 
       // --- Pause between iterations ---
@@ -607,11 +676,12 @@ export async function runLoop(options = {}) {
         }
       }
 
+      await writeReportEvent(cwd, { event: 'iteration_start', iteration: i, type: 'execution' });
+
       let iterResult;
       try {
         iterResult = await spawnClaude(execPrompt, { ...spawnOpts, cwd: iterCwd, sessionId });
       } catch (err) {
-        console.error(`\n  Iteration ${i} failed: ${err.message}`);
         // In worktree mode, clean up the worktree on failure
         if (worktreeInfo) {
           try {
@@ -624,6 +694,26 @@ export async function runLoop(options = {}) {
             iteration: i,
           });
         }
+
+        // Rate limit detection — save state for resume
+        if (err.isRateLimit) {
+          log.stopReason = 'rate_limit';
+          log.pausedAt = { iteration: i, sessionId };
+          log.options = {
+            goal: options.goal,
+            model: options.model,
+            trust: options.trust,
+            maxTurns: options.maxTurns,
+            budget: options.budget,
+            worktree: options.worktree,
+          };
+          await writeLoopLog(cwd, log);
+          await writeReportEvent(cwd, { event: 'rate_limit', iteration: i, message: err.message });
+          console.log(`\n  Rate limited at iteration ${i}. Resume with: claudenv loop --resume`);
+          break;
+        }
+
+        console.error(`\n  Iteration ${i} failed: ${err.message}`);
         log.stopReason = 'error';
         break;
       }
@@ -696,6 +786,17 @@ export async function runLoop(options = {}) {
       log.totalIterations = i;
       printIterationSummary(iteration);
       await writeLoopLog(cwd, log);
+      await writeReportEvent(cwd, {
+        event: 'iteration_end',
+        iteration: i,
+        summary: iteration.summary,
+        commitHash: iteration.commitHash,
+        tokens: iterResult.usage ? { in: iterResult.usage.input_tokens, out: iterResult.usage.output_tokens } : null,
+      });
+
+      // Fallback for SessionEnd hook — regen INDEX.md from accumulated decisions
+      // so the next iteration's briefing is current.
+      try { await regenIndex({ cwd }); } catch { /* best-effort */ }
 
       // --- Convergence check ---
       if (detectConvergence(iterResult.result)) {
@@ -740,6 +841,11 @@ export async function runLoop(options = {}) {
 
   log.completedAt = new Date().toISOString();
   await writeLoopLog(cwd, log);
+  await writeReportEvent(cwd, {
+    event: 'loop_end',
+    reason: log.stopReason,
+    totalIterations: log.totalIterations,
+  });
   printFinalSummary(log);
 }
 

package/src/memory-context.js

@@ -0,0 +1,63 @@
+/**
+ * Builds the `--append-system-prompt` payload for `claudenv loop`.
+ *
+ * Three composable fragments, joined with blank lines:
+ *
+ *   1. Autonomy=law directive from the goal (existing 1.2.x behavior)
+ *   2. Vibe-decisions loop-mode marker so the skill skips pause-and-ask
+ *   3. Memory briefing — current INDEX.md contents, capped for cache stability
+ *
+ * Cache discipline: the function is pure on its inputs (goal + file state at
+ * call time). Loop.js calls it once per iteration but with stable inputs
+ * within a session, so the appended prompt remains stable.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { indexMdPath } from './memory-paths.js';
+
+const VIBE_LOOP_FRAGMENT = `## Vibe-decisions mode (loop)
+
+You are running inside \`claudenv loop\` in autonomous mode. When the
+vibe-decisions skill triggers: pick the approach, write the decision log
+immediately (Write tool to /memories/decisions/<date>-<slug>.md with the
+__VIBE_DECISION__ marker), continue with code. Do NOT pause for user
+confirmation. Do NOT ask "делать так?". The goal is law.`;
+
+const MAX_BRIEFING_CHARS = 4000;
+
+/**
+ * Build the system prompt suffix.
+ *
+ * @param {string|null} goal - The loop's --goal value (may be null)
+ * @param {object} [opts]
+ * @param {(goal: string) => string} [opts.autonomyBuilder] - Caller's autonomy prompt builder
+ * @param {boolean} [opts.includeMemoryBriefing] - Default true; false skips INDEX.md read (for tests)
+ * @returns {Promise<string|undefined>} The appended prompt, or undefined if nothing to add
+ */
+export async function buildSystemPromptWithMemory(goal, opts = {}) {
+  const parts = [];
+
+  if (goal && opts.autonomyBuilder) {
+    parts.push(opts.autonomyBuilder(goal));
+  }
+
+  // Vibe-decisions loop mode is always on inside `claudenv loop`.
+  parts.push(VIBE_LOOP_FRAGMENT);
+
+  // Memory briefing — INDEX.md if present.
+  if (opts.includeMemoryBriefing !== false) {
+    try {
+      const briefing = await readFile(indexMdPath(), 'utf-8');
+      const capped =
+        briefing.length > MAX_BRIEFING_CHARS
+          ? briefing.slice(0, MAX_BRIEFING_CHARS) + '\n…(truncated)'
+          : briefing;
+      parts.push('## Memory briefing\n\n' + capped);
+    } catch {
+      /* INDEX.md absent — first session, fine */
+    }
+  }
+
+  if (parts.length === 0) return undefined;
+  return parts.join('\n\n');
+}

package/src/memory-paths.js

@@ -0,0 +1,86 @@
+/**
+ * Shared resolvers for the claudenv memory layout + a minimal YAML frontmatter
+ * parser used by hooks, CLI commands, and the loop integration.
+ *
+ * All path getters read process.env.CLAUDENV_HOME so tests can isolate without
+ * touching the real ~/.claudenv/.
+ */
+
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function claudenvHome() {
+  return process.env.CLAUDENV_HOME || join(homedir(), '.claudenv');
+}
+
+export function memoriesDir() {
+  return join(claudenvHome(), 'memories');
+}
+
+export function globalDecisionsDir() {
+  return join(memoriesDir(), 'decisions');
+}
+
+export function canonIndexPath() {
+  return join(memoriesDir(), 'canon', 'index.yaml');
+}
+
+export function userPrefsPath() {
+  return join(memoriesDir(), 'user', 'preferences.md');
+}
+
+export function indexMdPath() {
+  return join(memoriesDir(), 'INDEX.md');
+}
+
+export function dirtyFlagPath() {
+  return join(claudenvHome(), '.index-dirty');
+}
+
+export function projectDecisionsDir(cwd) {
+  return join(cwd, '.claude', 'memories', 'decisions');
+}
+
+/**
+ * Minimal YAML frontmatter parser. Returns null when no frontmatter is present.
+ * Handles `key: value` and inline arrays `[a, b, c]`. Heavier structures fall
+ * through as raw strings — frontmatter here is intentionally flat.
+ */
+export function parseFrontmatter(text) {
+  const match = /^---\n([\s\S]*?)\n---/.exec(text);
+  if (!match) return null;
+  const result = {};
+  for (const line of match[1].split('\n')) {
+    const m = /^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!m) continue;
+    let value = m[2].trim();
+    if (value.startsWith('[') && value.endsWith(']')) {
+      value = value
+        .slice(1, -1)
+        .split(',')
+        .map((s) => s.trim().replace(/^['"]|['"]$/g, ''))
+        .filter(Boolean);
+    } else {
+      value = value.replace(/^['"]|['"]$/g, '');
+    }
+    result[m[1]] = value;
+  }
+  return result;
+}
+
+/**
+ * Render a flat object back into a YAML frontmatter block.
+ * Preserves array fields as inline `[a, b]`.
+ */
+export function renderFrontmatter(obj) {
+  const lines = ['---'];
+  for (const [key, value] of Object.entries(obj)) {
+    if (Array.isArray(value)) {
+      lines.push(`${key}: [${value.join(', ')}]`);
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push('---');
+  return lines.join('\n');
+}