wendkeep 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Automatically capture AI coding agent sessions (Claude Code, Codex) as local Markdown in your Obsidian vault — turn-by-turn history, cost/token tracking, auto-extracted decisions/bugs/learnings, rendered in the graph. Local-first.",
   "type": "module",
   "bin": {

package/src/companion-select.mjs

@@ -0,0 +1,111 @@
+// Interactive companion checkbox selector for `wendkeep init`.
+// The state machine (initial/reduce/render/mapKey) is pure and tested; the raw-TTY
+// event loop is a thin shell over it, with a text fallback when raw mode is absent.
+import readline from 'node:readline';
+
+const HINT = 'Espaço marca/desmarca · ↑/↓ move · a=todos · n=nenhum · Enter confirma';
+
+export function initialCompanionMenu(companions) {
+  return {
+    items: companions.map((c) => ({ id: c.id, label: c.label, checked: !!c.default })),
+    cursor: 0,
+  };
+}
+
+export function reduceCompanionMenu(state, action) {
+  const n = state.items.length;
+  switch (action) {
+    case 'up':
+      return { ...state, cursor: (state.cursor - 1 + n) % n };
+    case 'down':
+      return { ...state, cursor: (state.cursor + 1) % n };
+    case 'space':
+      return {
+        ...state,
+        items: state.items.map((it, i) => (i === state.cursor ? { ...it, checked: !it.checked } : it)),
+      };
+    case 'all':
+      return { ...state, items: state.items.map((it) => ({ ...it, checked: true })) };
+    case 'none':
+      return { ...state, items: state.items.map((it) => ({ ...it, checked: false })) };
+    case 'enter':
+      return { ...state, done: true, selected: state.items.filter((it) => it.checked).map((it) => it.id) };
+    default:
+      return state;
+  }
+}
+
+export function renderCompanionMenu(state) {
+  const lines = [`Companions — ${HINT}:`];
+  state.items.forEach((it, i) => {
+    const cursor = i === state.cursor ? '>' : ' ';
+    const box = it.checked ? '[x]' : '[ ]';
+    lines.push(`${cursor} ${box} ${it.label}`);
+  });
+  return lines.join('\n');
+}
+
+export function mapKey(str, key = {}) {
+  const name = key.name;
+  if (name === 'up' || name === 'k') return 'up';
+  if (name === 'down' || name === 'j') return 'down';
+  if (name === 'space' || str === ' ') return 'space';
+  if (name === 'return' || name === 'enter') return 'enter';
+  if (str === 'a') return 'all';
+  if (str === 'n') return 'none';
+  return null;
+}
+
+// True when stdin/stdout can drive an interactive raw-mode menu.
+export function canInteractiveSelect(input = process.stdin, output = process.stdout) {
+  return !!(input && output && input.isTTY && output.isTTY && typeof input.setRawMode === 'function');
+}
+
+// Run the raw-TTY checkbox menu; resolves with the selected ids. Caller must check
+// canInteractiveSelect() first (otherwise use the text fallback).
+export function selectCompanionsInteractive(companions, { input = process.stdin, output = process.stdout } = {}) {
+  return new Promise((resolve) => {
+    let state = initialCompanionMenu(companions);
+    let drawnLines = 0;
+
+    readline.emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+
+    const draw = () => {
+      if (drawnLines) {
+        readline.moveCursor(output, 0, -drawnLines);
+        readline.clearScreenDown(output);
+      }
+      const text = renderCompanionMenu(state);
+      output.write(`${text}\n`);
+      drawnLines = text.split('\n').length;
+    };
+
+    const cleanup = () => {
+      input.removeListener('keypress', onKey);
+      if (typeof input.setRawMode === 'function') input.setRawMode(false);
+      input.pause();
+    };
+
+    const onKey = (str, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        output.write('\n');
+        process.exit(130);
+      }
+      const action = mapKey(str, key);
+      if (!action) return;
+      state = reduceCompanionMenu(state, action);
+      if (state.done) {
+        cleanup();
+        resolve(state.selected);
+        return;
+      }
+      draw();
+    };
+
+    input.on('keypress', onKey);
+    draw();
+  });
+}

package/src/init.mjs

@@ -3,7 +3,8 @@
 // OBSIDIAN_VAULT_PATH into .claude/settings.json, and adds the mcpvault server to
 // .mcp.json. Idempotent: re-running only adds what is missing.
 import { spawnSync } from 'node:child_process';
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { basename, isAbsolute, join, resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import {
@@ -19,8 +20,10 @@ import {
   companionMcpPatch,
   companionHookSpecs,
   cavemanInstallerCommand,
+  cavemanInstallerUrl,
 } from './taxonomy.mjs';
 import { renderVaultReadme } from './vault-readme.mjs';
+import { canInteractiveSelect, selectCompanionsInteractive } from './companion-select.mjs';
 
 function parseArgs(argv) {
   const args = { mcp: true, yes: false, force: false };
@@ -117,6 +120,32 @@ export function mergeMcp(existing, { vaultPath, withVault = true, companions = [
   return m;
 }
 
+// Run caveman's cross-agent installer (non-Claude skill coverage). Downloads the
+// script to a temp file and runs it as a FILE — piping to iex/bash leaves the
+// script's self-path null and the installer aborts. Best-effort, fail-soft: the
+// Claude Code plugin entry is already wired regardless.
+async function runCavemanInstaller(log) {
+  const url = cavemanInstallerUrl();
+  const ext = process.platform === 'win32' ? 'ps1' : 'sh';
+  const tmp = join(tmpdir(), `wendkeep-caveman-install-${process.pid}.${ext}`);
+  log(`\n  caveman: fetching cross-agent installer (best-effort): ${url}`);
+  try {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    writeFileSync(tmp, await res.text(), 'utf8');
+    const cmd = cavemanInstallerCommand(process.platform, tmp);
+    log(`  caveman: running ${cmd.command} ${cmd.args.join(' ')}`);
+    const r = spawnSync(cmd.command, cmd.args, { stdio: 'inherit' });
+    if (r.status !== 0) {
+      log(`  [!] caveman installer exited ${r.status ?? '?'} — Claude Code plugin entry still wired; rerun manually if needed.`);
+    }
+  } catch (e) {
+    log(`  [!] caveman installer skipped (${e.message}) — Claude Code plugin entry still wired.`);
+  } finally {
+    try { rmSync(tmp, { force: true }); } catch { /* temp cleanup best-effort */ }
+  }
+}
+
 // --- main -------------------------------------------------------------------
 
 export async function runInit(argv) {
@@ -129,7 +158,7 @@ export async function runInit(argv) {
     const fallback = join(projectPath, deriveVaultDirName(projectPath));
     if (process.stdin.isTTY && !args.yes) {
       const rl = createInterface({ input: process.stdin, output: process.stdout });
-      const ans = (await rl.question(`Obsidian vault path [${fallback}]: `)).trim();
+      const ans = (await rl.question(`Obsidian vault path (Enter aceita o padrão, ou digite outro caminho)\n  [${fallback}]\n> `)).trim();
       rl.close();
       vaultPath = ans || fallback;
     } else {
@@ -147,13 +176,21 @@ export async function runInit(argv) {
   } else if (args.companions !== undefined) {
     companions = resolveCompanions({ companionsFlag: args.companions });
   } else if (process.stdin.isTTY && !args.yes) {
-    log('\nCompanions (plugins/MCP opcionais — context-mode é a principal):');
-    for (const c of COMPANIONS) log(`  ${c.default ? '[x]' : '[ ]'} ${c.label}`);
-    const def = resolveCompanions({}).join(',');
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    const ans = (await rl.question(`Instalar quais? (vírgula) [${def}], "none" p/ nenhum: `)).trim();
-    rl.close();
-    companions = ans.toLowerCase() === 'none' ? [] : resolveCompanions({ companionsFlag: ans || def });
+    if (canInteractiveSelect()) {
+      log(''); // the checkbox menu renders its own header
+      companions = await selectCompanionsInteractive(COMPANIONS);
+    } else {
+      // Text fallback (no raw-mode TTY): list + comma input with clear instructions.
+      log('\nCompanions (plugins/MCP opcionais — context-mode é a principal):');
+      for (const c of COMPANIONS) log(`  ${c.default ? '[x]' : '[ ]'} ${c.label}`);
+      const def = resolveCompanions({}).join(',');
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const ans = (await rl.question(
+        `Digite os ids separados por vírgula (Enter aceita [${def}], "none" p/ nenhum): `,
+      )).trim();
+      rl.close();
+      companions = ans.toLowerCase() === 'none' ? [] : resolveCompanions({ companionsFlag: ans || def });
+    }
   } else {
     companions = resolveCompanions({});
   }
@@ -223,18 +260,7 @@ export async function runInit(argv) {
   // caveman has no MCP / agnostic-hook path: on non-Claude agents its skills come
   // from its own cross-agent installer. Best-effort, fail-soft — the Claude Code
   // plugin entry is already wired in settings.json regardless.
-  if (companions.includes('caveman')) {
-    const cmd = cavemanInstallerCommand();
-    log(`\n  caveman: running cross-agent installer (best-effort): ${cmd.command} ${cmd.args.join(' ')}`);
-    try {
-      const r = spawnSync(cmd.command, cmd.args, { stdio: 'inherit' });
-      if (r.status !== 0) {
-        log(`  [!] caveman installer exited ${r.status ?? '?'} — Claude Code plugin entry still wired; rerun manually if needed.`);
-      }
-    } catch (e) {
-      log(`  [!] caveman installer could not run (${e.code || e.message}) — Claude Code plugin entry still wired.`);
-    }
-  }
+  if (companions.includes('caveman')) await runCavemanInstaller(log);
 
   log('\nNext steps:');
   log(`  1. Open the vault in Obsidian: "Open folder as vault" -> ${vaultPath}`);

package/src/taxonomy.mjs

@@ -178,15 +178,21 @@ export function companionHookSpecs(ids) {
   return specs;
 }
 
-// Build the platform-appropriate command to run caveman's own cross-agent installer
-// (used on non-Claude agents — caveman has no MCP/agnostic-hook path). Pure: returns
-// {command, args}; the caller decides whether to spawn it.
-export function cavemanInstallerCommand(platform = process.platform) {
+// The caveman installer URL for this platform (.ps1 on Windows, .sh elsewhere).
+export function cavemanInstallerUrl(platform = process.platform) {
   const { sh, ps1 } = COMPANION_BY_ID.caveman.installer;
+  return platform === 'win32' ? ps1 : sh;
+}
+
+// Command to run caveman's installer FROM A LOCAL FILE. We download the script to a
+// temp file and run it as a file (not `irm|iex` / `curl|bash`) so the script gets a
+// real $PSCommandPath/$0 — piping to iex leaves that null and the installer aborts
+// ("cannot bind argument to parameter 'Path'"). Pure: returns {command, args}.
+export function cavemanInstallerCommand(platform = process.platform, scriptPath) {
   if (platform === 'win32') {
-    return { command: 'powershell', args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', `irm ${ps1} | iex`] };
+    return { command: 'powershell', args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', scriptPath] };
   }
-  return { command: 'bash', args: ['-c', `curl -fsSL ${sh} | bash`] };
+  return { command: 'bash', args: [scriptPath] };
 }
 
 // Derive the default vault folder name from the project folder: `.<project>-vault`.