clawvault 1.4.0 → 1.4.2

package/README.md

@@ -55,13 +55,16 @@ clawvault search "decision"           # BM25 keyword search
 clawvault vsearch "what did I decide" # Semantic search
 
 # Session management
-clawvault handoff --working-on "task1" --next "task2"  # Before context death
-clawvault recap                                          # On session start
+clawvault wake
+clawvault sleep "build wake/sleep commands" --next "run doctor"
+clawvault handoff --working-on "task1" --next "task2"   # Manual handoff (advanced)
+clawvault recap                                         # Manual recap (advanced)
 ```
 
-**Tip:** Set `CLAWVAULT_PATH` environment variable to skip directory walk:
+**Tip:** Set `CLAWVAULT_PATH` to skip directory walk (or use `shell-init`):
 ```bash
 echo 'export CLAWVAULT_PATH="$HOME/memory"' >> ~/.bashrc
+eval "$(clawvault shell-init)"
 ```
 
 ## Search: qmd vs memory_search
@@ -135,18 +138,19 @@ clawvault stats               # Vault overview
 ### Session Continuity
 
 ```bash
-# Before context death (long pause, session end, hitting limits)
-clawvault handoff \
-  --working-on "building CRM, fixing webhook" \
+# Start a session (recover + recap + summary)
+clawvault wake
+
+# End a session with a handoff
+clawvault sleep "building CRM, fixing webhook" \
   --blocked "waiting for API key" \
   --next "deploy to production" \
   --decisions "chose Supabase over Firebase" \
   --feeling "focused"
 
-# On session start
-clawvault recap           # Full markdown recap
-clawvault recap --brief   # Token-efficient version
-clawvault recap --json    # For programmatic use
+# Manual tools (advanced)
+clawvault handoff --working-on "task1" --next "task2"
+clawvault recap --brief   # Token-efficient recap
 
 # Health check
 clawvault doctor
@@ -173,15 +177,19 @@ clawvault remember decision "Title" --content "..."
 clawvault remember lesson "Title" --content "..."
 \`\`\`
 
-### Session Handoff
-Before context death:
+### Session Start
+\`\`\`bash
+clawvault wake
+\`\`\`
+
+### Session End
 \`\`\`bash
-clawvault handoff --working-on "..." --next "..."
+clawvault sleep "..." --next "..."
 \`\`\`
 
-On wake:
+### Checkpoint (during heavy work)
 \`\`\`bash
-clawvault recap
+clawvault checkpoint --working-on "..." --focus "..." --blocked "..."
 \`\`\`
 
 ### Why qmd over memory_search?

package/bin/clawvault.js

@@ -14,7 +14,6 @@ import {
   ClawVault,
   createVault,
   findVault,
-  hasQmd,
   QmdUnavailableError,
   QMD_INSTALL_COMMAND
 } from '../dist/index.js';
@@ -59,6 +58,28 @@ async function getVault(vaultPath) {
   return vault;
 }
 
+function resolveVaultPath(vaultPath) {
+  if (vaultPath) {
+    return path.resolve(vaultPath);
+  }
+  if (process.env.CLAWVAULT_PATH) {
+    return path.resolve(process.env.CLAWVAULT_PATH);
+  }
+  let current = process.cwd();
+  while (true) {
+    if (fs.existsSync(path.join(current, '.clawvault.json'))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      console.error(chalk.red('Error: No ClawVault found. Run `clawvault init` first.'));
+      console.log(chalk.dim('Tip: Set CLAWVAULT_PATH environment variable to your vault path'));
+      process.exit(1);
+    }
+    current = parent;
+  }
+}
+
 async function runQmd(args) {
   return new Promise((resolve, reject) => {
     const proc = spawn('qmd', args, { stdio: 'inherit' });
@@ -571,6 +592,117 @@ program
     }
   });
 
+// === WAKE (session start) ===
+program
+  .command('wake')
+  .description('Start a session (recover + recap + summary)')
+  .option('-n, --handoff-limit <n>', 'Number of recent handoffs to include', '3')
+  .option('--full', 'Show full recap (default: brief)')
+  .option('-v, --vault <path>', 'Vault path')
+  .action(async (options) => {
+    try {
+      const vaultPath = resolveVaultPath(options.vault);
+      const { wake } = await import('../dist/commands/wake.js');
+      const { formatRecoveryInfo } = await import('../dist/commands/recover.js');
+      const result = await wake({
+        vaultPath,
+        handoffLimit: parseInt(options.handoffLimit),
+        brief: !options.full
+      });
+
+      console.log(chalk.cyan('\n🌅 ClawVault Wake\n'));
+      console.log(formatRecoveryInfo(result.recovery));
+      console.log();
+      console.log(chalk.cyan('Recap'));
+      console.log(result.recapMarkdown.trim());
+      console.log();
+      console.log(chalk.green(`You were working on: ${result.summary}`));
+
+      process.exitCode = result.recovery.died ? 1 : 0;
+    } catch (err) {
+      if (err instanceof QmdUnavailableError) {
+        printQmdMissing();
+        process.exit(1);
+      }
+      console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+// === SLEEP (session end) ===
+program
+  .command('sleep <summary>')
+  .description('End a session with a handoff (and optional git commit)')
+  .option('-n, --next <items>', 'Next steps (comma-separated)')
+  .option('-b, --blocked <items>', 'Blocked items (comma-separated)')
+  .option('-d, --decisions <items>', 'Key decisions made (comma-separated)')
+  .option('-q, --questions <items>', 'Open questions (comma-separated)')
+  .option('-f, --feeling <state>', 'Emotional/energy state')
+  .option('-s, --session <key>', 'Session key')
+  .option('--index', 'Update qmd index after handoff')
+  .option('--no-git', 'Skip git commit prompt')
+  .option('-v, --vault <path>', 'Vault path')
+  .action(async (summary, options) => {
+    try {
+      const vaultPath = resolveVaultPath(options.vault);
+      const { sleep } = await import('../dist/commands/sleep.js');
+      const result = await sleep({
+        workingOn: summary,
+        next: options.next,
+        blocked: options.blocked,
+        decisions: options.decisions,
+        questions: options.questions,
+        feeling: options.feeling,
+        sessionKey: options.session,
+        vaultPath,
+        index: options.index,
+        git: options.git
+      });
+
+      console.log(chalk.green(`✓ Handoff saved: ${result.document.id}`));
+      console.log(chalk.dim(`  Path: ${result.document.path}`));
+      console.log(chalk.dim(`  Working on: ${result.handoff.workingOn.join(', ')}`));
+      if (result.handoff.nextSteps.length > 0) {
+        console.log(chalk.dim(`  Next: ${result.handoff.nextSteps.join(', ')}`));
+      } else {
+        console.log(chalk.dim('  Next: (none)'));
+      }
+      if (result.handoff.blocked.length > 0) {
+        console.log(chalk.dim(`  Blocked: ${result.handoff.blocked.join(', ')}`));
+      } else {
+        console.log(chalk.dim('  Blocked: (none)'));
+      }
+      if (result.handoff.decisions?.length) {
+        console.log(chalk.dim(`  Decisions: ${result.handoff.decisions.join(', ')}`));
+      }
+      if (result.handoff.openQuestions?.length) {
+        console.log(chalk.dim(`  Questions: ${result.handoff.openQuestions.join(', ')}`));
+      }
+      if (result.handoff.feeling) {
+        console.log(chalk.dim(`  Feeling: ${result.handoff.feeling}`));
+      }
+      if (options.index) {
+        console.log(chalk.dim('  qmd: index updated'));
+      }
+      if (result.git) {
+        if (result.git.committed) {
+          console.log(chalk.green(`✓ Git commit created${result.git.message ? `: ${result.git.message}` : ''}`));
+        } else if (result.git.skippedReason === 'clean') {
+          console.log(chalk.dim('  Git: clean'));
+        } else if (result.git.skippedReason === 'declined') {
+          console.log(chalk.dim('  Git: commit skipped'));
+        }
+      }
+    } catch (err) {
+      if (err instanceof QmdUnavailableError) {
+        printQmdMissing();
+        process.exit(1);
+      }
+      console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
 // === HANDOFF (session bridge) ===
 program
   .command('handoff')
@@ -651,6 +783,20 @@ program
     }
   });
 
+// === SHELL INIT ===
+program
+  .command('shell-init')
+  .description('Output shell integration for ClawVault')
+  .action(async () => {
+    try {
+      const { shellInit } = await import('../dist/commands/shell-init.js');
+      console.log(shellInit());
+    } catch (err) {
+      console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
 // === TEMPLATE ===
 const template = program
   .command('template')
@@ -725,59 +871,39 @@ program
   .description('Check ClawVault setup health')
   .option('-v, --vault <path>', 'Vault path')
   .action(async (options) => {
-    console.log(chalk.cyan('\n🩺 ClawVault Health Check\n'));
-    
-    let issues = 0;
-    
-    // Check qmd
-    if (hasQmd()) {
-      console.log(chalk.green('✓ qmd installed'));
-    } else {
-      console.log(chalk.red('✗ qmd not installed'));
-      console.log(chalk.dim(`  Install: ${QMD_INSTALL_COMMAND}`));
-      issues++;
-    }
-    
-    // Check vault
     try {
-      const vault = await getVault(options.vault);
-      console.log(chalk.green(`✓ Vault found: ${vault.getPath()}`));
-      
-      const stats = await vault.stats();
-      console.log(chalk.dim(`  ${stats.documents} documents, ${stats.links} links`));
-      
-      // Check qmd collection
-      const collection = vault.getQmdCollection();
-      if (collection) {
-        console.log(chalk.green(`✓ qmd collection: ${collection}`));
-      } else {
-        console.log(chalk.yellow('⚠ No qmd collection configured'));
-        issues++;
+      const { doctor } = await import('../dist/commands/doctor.js');
+      const report = await doctor(options.vault);
+
+      console.log(chalk.cyan('\n🩺 ClawVault Health Check\n'));
+      if (report.vaultPath) {
+        console.log(chalk.dim(`Vault: ${report.vaultPath}`));
+        console.log();
       }
-      
-      // Check for handoffs
-      const handoffs = await vault.list('handoffs');
-      if (handoffs.length > 0) {
-        console.log(chalk.green(`✓ ${handoffs.length} handoff(s) stored`));
-      } else {
-        console.log(chalk.yellow('⚠ No handoffs yet — run `clawvault handoff` before context death'));
+
+      for (const check of report.checks) {
+        const prefix = check.status === 'ok'
+          ? chalk.green('✓')
+          : check.status === 'warn'
+            ? chalk.yellow('⚠')
+            : chalk.red('✗');
+        const detail = check.detail ? ` — ${check.detail}` : '';
+        console.log(`${prefix} ${check.label}${detail}`);
+        if (check.hint) {
+          console.log(chalk.dim(`  ${check.hint}`));
+        }
       }
-      
-      // Check for content
-      if (stats.documents < 5) {
-        console.log(chalk.yellow('⚠ Vault is sparse — start storing memories!'));
+
+      const issues = report.warnings + report.errors;
+      console.log();
+      if (issues === 0) {
+        console.log(chalk.green('✅ ClawVault is healthy!\n'));
+      } else {
+        console.log(chalk.yellow(`⚠ ${issues} issue(s) found\n`));
       }
-      
     } catch (err) {
-      console.log(chalk.red(`✗ Vault error: ${err.message}`));
-      issues++;
-    }
-    
-    console.log();
-    if (issues === 0) {
-      console.log(chalk.green('✅ ClawVault is healthy!\n'));
-    } else {
-      console.log(chalk.yellow(`⚠ ${issues} issue(s) found\n`));
+      console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
     }
   });
 

package/dist/chunk-MILVYUPK.js

@@ -0,0 +1,146 @@
+import {
+  checkDirtyDeath,
+  clearDirtyFlag
+} from "./chunk-MZZJLQNQ.js";
+import {
+  formatAge
+} from "./chunk-7ZRP733D.js";
+
+// src/commands/recover.ts
+import * as fs from "fs";
+import * as path from "path";
+async function recover(vaultPath, options = {}) {
+  const { clearFlag = false } = options;
+  const { died, checkpoint, deathTime } = await checkDirtyDeath(vaultPath);
+  if (!died) {
+    return {
+      died: false,
+      deathTime: null,
+      checkpoint: null,
+      handoffPath: null,
+      handoffContent: null,
+      recoveryMessage: "No context death detected. Clean startup."
+    };
+  }
+  const handoffsDir = path.join(vaultPath, "handoffs");
+  let handoffPath = null;
+  let handoffContent = null;
+  if (fs.existsSync(handoffsDir)) {
+    const files = fs.readdirSync(handoffsDir).filter((f) => f.startsWith("handoff-") && f.endsWith(".md")).sort().reverse();
+    if (files.length > 0) {
+      handoffPath = path.join(handoffsDir, files[0]);
+      handoffContent = fs.readFileSync(handoffPath, "utf-8");
+    }
+  }
+  let message = "\u26A0\uFE0F **CONTEXT DEATH DETECTED**\n\n";
+  message += `Your previous session died at ${deathTime}.
+
+`;
+  if (checkpoint) {
+    message += "**Last known state:**\n";
+    if (checkpoint.workingOn) {
+      message += `- Working on: ${checkpoint.workingOn}
+`;
+    }
+    if (checkpoint.focus) {
+      message += `- Focus: ${checkpoint.focus}
+`;
+    }
+    if (checkpoint.blocked) {
+      message += `- Blocked: ${checkpoint.blocked}
+`;
+    }
+    message += "\n";
+  }
+  if (handoffPath) {
+    message += `**Last handoff:** ${path.basename(handoffPath)}
+`;
+    message += "Review and resume from where you left off.\n";
+  } else {
+    message += "**No handoff found.** You may have lost context.\n";
+  }
+  if (clearFlag) {
+    await clearDirtyFlag(vaultPath);
+  }
+  return {
+    died: true,
+    deathTime,
+    checkpoint,
+    handoffPath,
+    handoffContent,
+    recoveryMessage: message
+  };
+}
+function formatRecoveryInfo(info, options = {}) {
+  const { verbose = false } = options;
+  if (!info.died) {
+    return "\u2713 Clean startup - no context death detected.";
+  }
+  let output = "\n\u26A0\uFE0F  CONTEXT DEATH DETECTED\n";
+  output += "\u2550".repeat(40) + "\n\n";
+  output += `Death time: ${info.deathTime}
+`;
+  if (info.checkpoint?.timestamp) {
+    const age = formatAge(Date.now() - new Date(info.checkpoint.timestamp).getTime());
+    output += `Checkpoint: ${info.checkpoint.timestamp} (${age} ago)
+`;
+  }
+  output += "\n";
+  if (info.checkpoint) {
+    output += "Last checkpoint:\n";
+    if (info.checkpoint.workingOn) {
+      output += `  \u2022 Working on: ${info.checkpoint.workingOn}
+`;
+    }
+    if (info.checkpoint.focus) {
+      output += `  \u2022 Focus: ${info.checkpoint.focus}
+`;
+    }
+    if (info.checkpoint.blocked) {
+      output += `  \u2022 Blocked: ${info.checkpoint.blocked}
+`;
+    }
+    if (info.checkpoint.sessionKey || info.checkpoint.model || info.checkpoint.tokenEstimate !== void 0) {
+      output += "  \u2022 Session:\n";
+      if (info.checkpoint.sessionKey) {
+        output += `    - Key: ${info.checkpoint.sessionKey}
+`;
+      }
+      if (info.checkpoint.model) {
+        output += `    - Model: ${info.checkpoint.model}
+`;
+      }
+      if (info.checkpoint.tokenEstimate !== void 0) {
+        output += `    - Token estimate: ${info.checkpoint.tokenEstimate}
+`;
+      }
+    }
+    output += "\n";
+  } else {
+    output += "No checkpoint data found.\n\n";
+  }
+  if (info.handoffPath) {
+    output += `Last handoff: ${path.basename(info.handoffPath)}
+`;
+  } else {
+    output += "No handoff found - context may be lost.\n";
+  }
+  if (verbose) {
+    if (info.checkpoint) {
+      output += "\nCheckpoint JSON:\n";
+      output += JSON.stringify(info.checkpoint, null, 2) + "\n";
+    }
+    if (info.handoffContent) {
+      output += "\nHandoff content:\n";
+      output += info.handoffContent.trim() + "\n";
+    }
+  }
+  output += "\n" + "\u2550".repeat(40) + "\n";
+  output += "Run `clawvault recap` to see full context.\n";
+  return output;
+}
+
+export {
+  recover,
+  formatRecoveryInfo
+};

package/dist/commands/doctor.d.ts

@@ -0,0 +1,16 @@
+type DoctorStatus = 'ok' | 'warn' | 'error';
+interface DoctorCheck {
+    label: string;
+    status: DoctorStatus;
+    detail?: string;
+    hint?: string;
+}
+interface DoctorReport {
+    vaultPath?: string;
+    checks: DoctorCheck[];
+    warnings: number;
+    errors: number;
+}
+declare function doctor(vaultPath?: string): Promise<DoctorReport>;
+
+export { type DoctorCheck, type DoctorReport, type DoctorStatus, doctor };