claudenv 1.2.5 → 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],
+      },
     ],
   };
 

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/.
  *
@@ -95,7 +130,13 @@ export async function uninstallGlobal(options = {}) {
     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

@@ -3,6 +3,8 @@ 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
@@ -51,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 = {}) {
@@ -81,6 +84,7 @@ export function spawnClaude(prompt, options = {}) {
 
     const child = spawn('claude', args, {
       cwd: options.cwd || process.cwd(),
+      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'],
     });
@@ -520,6 +524,14 @@ export async function runLoop(options = {}) {
   };
 
   // --- 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,
@@ -527,7 +539,12 @@ 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 = options.initialSessionId || null;
@@ -585,6 +602,10 @@ export async function runLoop(options = {}) {
         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();
@@ -773,6 +794,10 @@ export async function runLoop(options = {}) {
         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)) {
         console.log('\n  All improvements completed.');

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');
+}

package/src/memory.js

@@ -0,0 +1,111 @@
+/**
+ * CLI: `claudenv memory init/index/show/edit`
+ *
+ * Owns the user-facing surface for the global ~/.claudenv/memories/ layout.
+ * Reuses regen-index for `index` so there's one canonical regeneration path.
+ */
+
+import { mkdir, readFile, writeFile, stat } from 'node:fs/promises';
+import { join, dirname, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import {
+  claudenvHome,
+  memoriesDir,
+  globalDecisionsDir,
+  canonIndexPath,
+  userPrefsPath,
+  indexMdPath,
+} from './memory-paths.js';
+import { regenIndex } from './hooks/regen-index.js';
+
+/**
+ * `claudenv memory init` — create the global memory layout if absent.
+ * Idempotent; never overwrites existing files.
+ */
+export async function memoryInit() {
+  const created = [];
+  const skipped = [];
+
+  // Layout
+  const dirs = [
+    memoriesDir(),
+    globalDecisionsDir(),
+    join(memoriesDir(), 'canon'),
+    join(memoriesDir(), 'user'),
+  ];
+  for (const d of dirs) {
+    await mkdir(d, { recursive: true });
+  }
+
+  // Seed files
+  const seeds = [
+    {
+      path: indexMdPath(),
+      content:
+        '# claudenv memory — INDEX\n\n> Auto-generated by `claudenv memory index`. Hand-edits will be overwritten.\n\n## Recent decisions\n\n_No decisions yet — vibe-decisions will log here._\n',
+    },
+    {
+      path: canonIndexPath(),
+      content:
+        '# Личный канон. Добавляйте через: claudenv canon add <topic> <url> --why "<reason>"\n',
+    },
+    {
+      path: join(claudenvHome(), '.gitignore'),
+      content: 'sessions/\n*.log\n.log/\nkeys/private*\n*.local.*\n*.secret.*\n',
+    },
+  ];
+
+  for (const { path, content } of seeds) {
+    try {
+      await stat(path);
+      skipped.push(path);
+    } catch {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, content, 'utf-8');
+      created.push(path);
+    }
+  }
+
+  return { created, skipped };
+}
+
+/**
+ * `claudenv memory index` — regenerate INDEX.md from current decisions + prefs.
+ */
+export async function memoryIndex({ cwd } = {}) {
+  return await regenIndex({ cwd: cwd || process.cwd() });
+}
+
+/**
+ * `claudenv memory show <relpath>` — print a file from memories/.
+ * Path is interpreted relative to ~/.claudenv/memories/.
+ */
+export async function memoryShow(relPath) {
+  if (!relPath) throw new Error('Usage: claudenv memory show <path>');
+  const full = resolve(memoriesDir(), relPath);
+  if (!full.startsWith(memoriesDir())) {
+    throw new Error('Path escapes memories root');
+  }
+  return await readFile(full, 'utf-8');
+}
+
+/**
+ * `claudenv memory edit <relpath>` — open a memory file in $EDITOR (or vi).
+ * Creates the file if missing.
+ */
+export async function memoryEdit(relPath) {
+  if (!relPath) throw new Error('Usage: claudenv memory edit <path>');
+  const full = resolve(memoriesDir(), relPath);
+  if (!full.startsWith(memoriesDir())) {
+    throw new Error('Path escapes memories root');
+  }
+  await mkdir(dirname(full), { recursive: true });
+  try {
+    await stat(full);
+  } catch {
+    await writeFile(full, '', 'utf-8');
+  }
+  const editor = process.env.EDITOR || 'vi';
+  const result = spawnSync(editor, [full], { stdio: 'inherit' });
+  return { path: full, exitCode: result.status ?? 0 };
+}