@haposoft/cafekit 0.13.4 → 0.14.0

package/README.md

@@ -2,7 +2,7 @@
 
 > Claude Code-first spec-driven workflow and runtime bundle for AI coding assistants.
 
-[![Version](https://img.shields.io/badge/version-0.13.4-blue.svg)](https://github.com/haposoft/cafekit)
+[![Version](https://img.shields.io/badge/version-0.9.3-blue.svg)](https://github.com/haposoft/cafekit)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Claude%20Code](https://img.shields.io/badge/Claude%20Code-Primary-orange.svg)](https://claude.ai/code)
 
@@ -46,26 +46,6 @@ Requirements:
 - Node.js 18+
 - Claude Code project with `.claude/`, OpenCode project with `.opencode/` or `opencode.json`, or choose a runtime when prompted
 
-## Git ignore policy
-
-On install, CafeKit updates the **project-root** `.gitignore` with:
-
-```text
-# CafeKit / Ecosystem
-specs/_shared/
-plans/
-!plans/templates/
-.cafekit-backup/
-.cafekit.lock
-.claude/
-.opencode/
-```
-
-Runtime folders are local — reinstall with `npx @haposoft/cafekit` rather than
-committing them. Inside the runtime, CafeKit also installs `.claude/.gitignore`
-(or `.opencode/.gitignore`) so secrets, skill dependencies, session state, and
-hook logs stay out of git even if someone force-adds the folder.
-
 ## What Gets Installed
 
 Claude Code targets:
@@ -131,9 +111,8 @@ CafeKit ships many skills, but the main release surface is:
 - `/hapo:docs [--init|--update|--summarize|--reconstruct]`: create project docs or reconstruct as-is system documentation from source code
 - `/hapo:test [scope|--full]`: run verification and return a structured verdict
 - `/hapo:code-review [scope|--pending]`: adversarial review focused on correctness, regressions, and security
-- `/hapo:generate-graph <diagram request>`: generate technical SVG/PNG diagrams
 
-Common companion skills bundled in this package include `inspect`, `impact-analysis`, `research`, `ai-multimodal`, `frontend-development`, `backend-development`, and `react-best-practices`.
+Common companion skills bundled in this package include `inspect`, `research`, `ai-multimodal`, `frontend-development`, `backend-development`, and `react-best-practices`.
 
 CafeKit uses rule-based skill routing guidance instead of an automatic prompt-scoring hook. See `.claude/rules/skill-workflow-routing.md`, `.claude/rules/skill-domain-routing.md`, or run:
 

package/bin/lib/i18n.js

@@ -366,11 +366,11 @@ const MESSAGES = {
   }
 };
 
-/** Normalize a language code to a supported one; unknown → 'ja'. */
+/** Normalize a language code to a supported one; unknown → 'en'. */
 function resolveLang(code) {
   if (!code) return 'en';
   const lc = String(code).toLowerCase().slice(0, 2);
-  return SUPPORTED.includes(lc) ? lc : 'ja';
+  return SUPPORTED.includes(lc) ? lc : 'en';
 }
 
 /** Build a translator. Falls back to English per-key, then the key itself. */

package/bin/lib/manifest.js

@@ -105,6 +105,21 @@ function createTracker(platformFolder, version) {
       this._pruned.add(key);
     },
 
+    /**
+     * Prune every tracked key under a directory prefix (e.g. "skills/foo/").
+     * Marks prior-manifest keys with the same prefix for deletion on write().
+     */
+    prunePrefix(relPrefix) {
+      const prefix = relPrefix.replace(/\\/g, '/');
+      for (const key of Object.keys(files)) {
+        if (key.startsWith(prefix)) delete files[key];
+      }
+      const prior = read(platformFolder);
+      for (const key of Object.keys(prior.files || {})) {
+        if (key.startsWith(prefix)) this._pruned.add(key);
+      }
+    },
+
     /** Recorded hash for a relPath written earlier this run, or null. */
     recorded(rel) {
       const key = rel.replace(/\\/g, '/');

package/bin/lib/opencode-install.js

@@ -94,13 +94,6 @@ const OPENCODE_COMMAND_TEMPLATES = [
     subtask: true,
     description: 'Inspect a codebase, artifact, or external context before planning.'
   },
-  {
-    fileName: 'generate-graph.md',
-    skillName: 'generate-graph',
-    agent: 'god-developer',
-    subtask: true,
-    description: 'Generate technical diagrams from project context.'
-  },
   // Domain skills — wrappers so users can invoke them directly via slash
   // commands. Each delegates to the matching skill under .opencode/skills/.
   {
@@ -166,13 +159,6 @@ const OPENCODE_COMMAND_TEMPLATES = [
     subtask: true,
     description: 'Run git workflows: branch, commit, tag, push, or release prep.'
   },
-  {
-    fileName: 'impact-analysis.md',
-    skillName: 'impact-analysis',
-    agent: 'inspector',
-    subtask: true,
-    description: 'Assess affected files, blast radius, and side effects of a change.'
-  },
   {
     fileName: 'mobile-development.md',
     skillName: 'mobile-development',

package/bin/phases/claude-runtime.js

@@ -78,11 +78,14 @@ function removeObsoleteClaudeRuntimeFiles(ctx, platformKey) {
     const targetPath = path.join(targetBase, relPath);
     if (!fs.existsSync(targetPath)) return;
 
+    const isDir = fs.statSync(targetPath).isDirectory();
     if (!ctx.dryRun) {
-      fs.rmSync(targetPath, { force: true });
+      fs.rmSync(targetPath, { force: true, recursive: isDir });
       // Remove the entry from the manifest so it doesn't linger as a zombie.
       if (ctx.trackers && ctx.trackers.claude) {
         ctx.trackers.claude.prune(relPath);
+        // Directories: prune every tracked file underneath as well.
+        if (isDir) ctx.trackers.claude.prunePrefix(`${relPath}/`);
       }
     }
     ctx.ui.detail(`  ↻ ${ctx.dryRun ? '[dry-run] ' : ''}Removed obsolete runtime: ${relPath}`);

package/bin/phases/claude-settings.js

@@ -85,7 +85,16 @@ function mergeClaudeSettings(ctx, platformKey) {
   const managedSettings = JSON.parse(fs.readFileSync(templatePath, 'utf8'));
   let existingSettings = {};
   if (fs.existsSync(targetPath)) {
-    existingSettings = JSON.parse(fs.readFileSync(targetPath, 'utf8'));
+    // A malformed user settings.json must not abort the whole install: skip the
+    // settings merge (never overwrite the user's file blind) and tell them why.
+    try {
+      existingSettings = JSON.parse(fs.readFileSync(targetPath, 'utf8'));
+    } catch (e) {
+      ctx.ui.warn(`Settings: ${targetPath} is not valid JSON (${e.message}). ` +
+        'Skipping settings merge — fix the file and re-run the installer.');
+      ctx.results.errors++;
+      return;
+    }
   }
 
   const mergedSettings = pruneObsoleteSettingsHooks({ ...existingSettings }, ctx);
@@ -100,7 +109,10 @@ function mergeClaudeSettings(ctx, platformKey) {
     }
   }
 
-  // hooks: append managed hooks that aren't already present (dedupe by command).
+  // hooks: merge managed hooks per command (not per entry). An entry is keyed
+  // by its matcher; commands missing from the matching entry are appended, so
+  // a new command added to an existing matcher entry is not swallowed on
+  // upgrade (the old dedupe only looked at each entry's FIRST command).
   if (managedSettings.hooks) {
     mergedSettings.hooks = mergedSettings.hooks || {};
     Object.keys(managedSettings.hooks).forEach((eventName) => {
@@ -108,14 +120,33 @@ function mergeClaudeSettings(ctx, platformKey) {
       const existingHooks = mergedSettings.hooks[eventName] || [];
       const mergedHooks = [...existingHooks];
 
+      // Commands already registered anywhere under this event (any matcher):
+      // a user may have moved a hook to another entry — never re-add it.
+      const eventCommands = new Set(
+        mergedHooks.flatMap((entry) => (entry?.hooks || []).map((h) => h?.command)).filter(Boolean)
+      );
+
       managedHooks.forEach((managedHook) => {
-        const managedCommand = managedHook.hooks?.[0]?.command || '';
-        const isDuplicate = mergedHooks.some((existingHook) =>
-          existingHook.hooks?.some((h) => h.command === managedCommand));
-        if (!isDuplicate) {
-          mergedHooks.push(managedHook);
+        const managedMatcher = managedHook.matcher || '';
+        const managedCommands = (managedHook.hooks || [])
+          .filter((h) => h?.command && !eventCommands.has(h.command));
+        if (managedCommands.length === 0) return;
+
+        const target = mergedHooks.find((entry) =>
+          (entry?.matcher || '') === managedMatcher && Array.isArray(entry?.hooks));
+
+        if (!target) {
+          mergedHooks.push({ ...managedHook, hooks: managedCommands });
+          managedCommands.forEach((h) => eventCommands.add(h.command));
           ctx.ui.detail(`  ✓ ${ctx.dryRun ? '[dry-run] ' : ''}Settings: hook ${eventName} merged`);
+          return;
         }
+
+        managedCommands.forEach((hook) => {
+          target.hooks.push(hook);
+          eventCommands.add(hook.command);
+        });
+        ctx.ui.detail(`  ✓ ${ctx.dryRun ? '[dry-run] ' : ''}Settings: hook ${eventName} merged (+${managedCommands.length} command${managedCommands.length > 1 ? 's' : ''})`);
       });
 
       mergedSettings.hooks[eventName] = mergedHooks;

package/bin/phases/root-config.js

@@ -1,29 +1,13 @@
 /**
  * Phase: root project configuration (.gitignore).
  *
- * Ensures the root .gitignore carries CafeKit-managed patterns:
- *  - workflow dirs (plans, shared research)
- *  - install safety artifacts (backup, lock)
- *  - runtime folders (.claude/, .opencode/) — reinstall via
- *    `npx @haposoft/cafekit`; do not commit the local payload
- *
- * Layered with the in-folder `.claude/.gitignore` /
- * `.opencode/.gitignore` templates (secrets, skill deps, session
- * state) so force-adds and partial un-ignores stay safe.
- *
- * Honors dry-run.
+ * Ensures the root .gitignore carries CafeKit-managed patterns, including the
+ * new install backup dir and lock file so they never get committed. Honors dry-run.
  */
 
 const fs = require('fs');
 const path = require('path');
 
-/** True if `lines` already carries `pattern` with or without a trailing slash. */
-function hasPattern(lines, pattern) {
-  const bare = pattern.replace(/\/$/, '');
-  const withSlash = bare + '/';
-  return lines.includes(pattern) || lines.includes(bare) || lines.includes(withSlash);
-}
-
 function ensureGitignore(ctx) {
   const gitignorePath = path.join(process.cwd(), '.gitignore');
   const header = '# CafeKit / Ecosystem';
@@ -32,10 +16,7 @@ function ensureGitignore(ctx) {
     'plans/',
     '!plans/templates/',
     '.cafekit-backup/',
-    '.cafekit.lock',
-    // Local runtime payload — reinstall with npx; keep out of git
-    '.claude/',
-    '.opencode/'
+    '.cafekit.lock'
   ];
   const prefix = ctx.dryRun ? '[dry-run] ' : '';
 
@@ -49,7 +30,7 @@ function ensureGitignore(ctx) {
 
   const content = fs.readFileSync(gitignorePath, 'utf8');
   const lines = content.split('\n').map((l) => l.trim());
-  const missing = patterns.filter((p) => !hasPattern(lines, p));
+  const missing = patterns.filter((p) => !lines.includes(p));
 
   if (missing.length > 0) {
     let newContent = content;
@@ -65,4 +46,4 @@ function ensureGitignore(ctx) {
   }
 }
 
-module.exports = { ensureGitignore, hasPattern };
+module.exports = { ensureGitignore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haposoft/cafekit",
-  "version": "0.13.4",
+  "version": "0.14.0",
   "description": "Claude Code-first spec-driven workflow for AI coding assistants. Bundles CafeKit hapo: skills, runtime hooks, agents, and installer scaffolding.",
   "author": "Haposoft <nghialt@haposoft.com>",
   "license": "MIT",

package/src/claude/agents/ui-ux-designer.md

@@ -25,10 +25,10 @@ You are an award-caliber UI/UX designer. You merge aesthetic excellence with eng
 ### Phase 1: Research & Trend Scouting
 - Execute explicit searches using the bundled `ui-ux-pro-max` toolkit:
   ```bash
-  python3 packages/spec/src/claude/skills/ui-ux-pro-max/scripts/search.py "<product-type>" --domain product
-  python3 packages/spec/src/claude/skills/ui-ux-pro-max/scripts/search.py "<style-keywords>" --domain style
-  python3 packages/spec/src/claude/skills/ui-ux-pro-max/scripts/search.py "<mood>" --domain typography
-  python3 packages/spec/src/claude/skills/ui-ux-pro-max/scripts/search.py "<industry>" --domain color
+  .claude/skills/.venv/bin/python3 .claude/skills/ui-ux-pro-max/scripts/search.py "<product-type>" --domain product
+  .claude/skills/.venv/bin/python3 .claude/skills/ui-ux-pro-max/scripts/search.py "<style-keywords>" --domain style
+  .claude/skills/.venv/bin/python3 .claude/skills/ui-ux-pro-max/scripts/search.py "<mood>" --domain typography
+  .claude/skills/.venv/bin/python3 .claude/skills/ui-ux-pro-max/scripts/search.py "<industry>" --domain color
   ```
 - Study current design trends sourced from Dribbble, Awwwards, Mobbin via the python extractor outputs.
 - Review existing `docs/design-guidelines.md` if it exists.

package/src/claude/gitignore

@@ -1,26 +1,19 @@
-# CafeKit local runtime (.claude/ or .opencode/)
-# Also ignored at project root by the installer. This file protects
-# force-adds (`git add -f`) and partial un-ignores of the runtime folder.
-
-# Secrets and local credentials
+# Environment and Sandbox credentials within .claude
 .env
 .env.*
 !.env.example
 
-# Skill dependency installs (Python venv + npm)
+# Virtual environments for python scripts (skills)
 skills/.venv/
-skills/**/.venv/
-skills/**/node_modules/
 .venv/
 venv/
+skills/**/node_modules/
 __pycache__/
-**/__pycache__/
 *.pyc
 
-# Generated session state, caches, and logs
+# System generated state, caches, and logs
 session-state/
 hooks/.logs/
-plugins/.logs/
 agent-memory/
 settings.bak.json
 .mcp.json

package/src/claude/hooks/__tests__/privacy-block.test.js

@@ -0,0 +1,79 @@
+'use strict';
+
+// Behavioral tests for privacy-block.cjs. The hook is run as a real subprocess:
+// a PreToolUse payload is piped to stdin and the exit code is asserted
+// (0 = allow, 2 = block). Covers the symlink-bypass hardening.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const HOOK = path.join(__dirname, '..', 'privacy-block.cjs');
+
+/** Run the hook with a tool payload; return { code, stderr }. */
+function runHook(payload, cwd) {
+  const res = spawnSync(process.execPath, [HOOK], {
+    input: JSON.stringify({ ...payload, cwd: cwd || payload.cwd }),
+    encoding: 'utf8',
+  });
+  return { code: res.status, stderr: res.stderr || '' };
+}
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ck-privacy-'));
+}
+
+test('blocks a direct Read of .env (exit 2)', () => {
+  const dir = tmpDir();
+  try {
+    const env = path.join(dir, '.env');
+    fs.writeFileSync(env, 'SECRET=1');
+    const { code } = runHook({ tool_name: 'Read', tool_input: { file_path: env } }, dir);
+    assert.strictEqual(code, 2);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('blocks a symlink whose target is .env (regression: symlink bypass)', () => {
+  const dir = tmpDir();
+  try {
+    const env = path.join(dir, '.env');
+    fs.writeFileSync(env, 'SECRET=1');
+    const link = path.join(dir, 'notes.txt'); // harmless-looking name
+    fs.symlinkSync(env, link);
+    const { code } = runHook({ tool_name: 'Read', tool_input: { file_path: link } }, dir);
+    assert.strictEqual(code, 2, 'symlink to .env must be blocked, not allowed');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('allows a normal non-sensitive file (exit 0)', () => {
+  const dir = tmpDir();
+  try {
+    const f = path.join(dir, 'README.md');
+    fs.writeFileSync(f, '# hi');
+    const { code } = runHook({ tool_name: 'Read', tool_input: { file_path: f } }, dir);
+    assert.strictEqual(code, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('allows a symlink to an exempt .env.example (exemption still wins)', () => {
+  const dir = tmpDir();
+  try {
+    const example = path.join(dir, '.env.example');
+    fs.writeFileSync(example, 'SECRET=');
+    const link = path.join(dir, 'sample.txt');
+    fs.symlinkSync(example, link);
+    const { code } = runHook({ tool_name: 'Read', tool_input: { file_path: link } }, dir);
+    assert.strictEqual(code, 0, 'symlink to an exempt file must stay allowed');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/claude/hooks/__tests__/session-writeenv.test.js

@@ -0,0 +1,68 @@
+'use strict';
+
+// Behavioral test for session.cjs writeEnv escaping. A git branch name is an
+// attacker-influenced value that flows into GIT_BRANCH in CLAUDE_ENV_FILE. If
+// the value is not escaped, sourcing that env file expands `$HOME` and executes
+// the `pwd` command substitution. We build a repo whose branch carries both
+// payloads (space-free, since git bans spaces in refs), run the hook, then
+// source the produced env file and assert GIT_BRANCH read back is the exact
+// literal branch name — nothing expanded or executed.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const HOOK = path.join(__dirname, '..', 'session.cjs');
+
+function git(args, cwd) {
+  const res = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  if (res.status !== 0) {
+    throw new Error(`git ${args.join(' ')} failed: ${res.stderr}`);
+  }
+  return res.stdout.trim();
+}
+
+test('session.cjs escapes shell metacharacters in GIT_BRANCH (no injection when sourced)', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-session-'));
+  const envFile = path.join(dir, 'env.sh');
+  try {
+    // Branch name carries both a $HOME expansion and a `pwd` command
+    // substitution. Both are space-free so git accepts them as a valid ref.
+    const payloadBranch = 'evil$HOME-x`pwd`';
+    git(['init', '-q'], dir);
+    git(['config', 'user.email', 't@t.co'], dir);
+    git(['config', 'user.name', 't'], dir);
+    git(['commit', '-q', '--allow-empty', '-m', 'init'], dir);
+    git(['checkout', '-q', '-b', payloadBranch], dir);
+
+    // Run the hook exactly as Claude Code would (SessionStart on stdin).
+    const res = spawnSync(process.execPath, [HOOK], {
+      cwd: dir,
+      input: JSON.stringify({ source: 'startup' }),
+      encoding: 'utf8',
+      env: { ...process.env, CLAUDE_ENV_FILE: envFile },
+    });
+    assert.strictEqual(res.status, 0, 'hook must exit 0 (fail-open)');
+    assert.ok(fs.existsSync(envFile), 'env file must be written');
+
+    const envText = fs.readFileSync(envFile, 'utf8');
+    const branchLine = envText.split('\n').find((l) => l.startsWith('export GIT_BRANCH='));
+    assert.ok(branchLine, 'GIT_BRANCH must be present');
+    assert.ok(branchLine.includes('\\$') && branchLine.includes('\\`'), 'both $ and backtick must be escaped');
+
+    // The real proof: source the env file, then echo the value back. It must
+    // equal the literal branch name — no $HOME expansion, no pwd execution.
+    const sourced = spawnSync('sh', ['-c', `. "${envFile}" && printf '%s' "$GIT_BRANCH"`], { encoding: 'utf8' });
+    assert.strictEqual(sourced.status, 0, 'sourcing env file should succeed');
+    assert.strictEqual(
+      sourced.stdout,
+      payloadBranch,
+      'GIT_BRANCH must read back as the exact literal branch (no expansion/execution)',
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});