lakonai 0.6.1

package/src/install/platforms.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { backupFile, restoreAllBackups } = require('./backup');
+const { installHook, uninstallHook } = require('./claude-hook');
+const { installCommands, uninstallCommands } = require('./claude-commands');
+const { claudeConfigDir } = require('./paths');
+
+const MARK_BEGIN = '<!-- lakon:begin -->';
+const MARK_END = '<!-- lakon:end -->';
+
+function wrap(rule) {
+  return `${MARK_BEGIN}\n${rule.trim()}\n${MARK_END}\n`;
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function dirExists(p) {
+  try { return fs.statSync(p).isDirectory(); } catch { return false; }
+}
+
+function readSafe(p) {
+  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+}
+
+function hasBlock(filePath) {
+  const existing = readSafe(filePath);
+  /* c8 ignore next */
+  if (!existing) return false;
+  const re = new RegExp(`${MARK_BEGIN}[\\s\\S]*?${MARK_END}`);
+  return re.test(existing);
+}
+
+function upsertBlock(platformId, filePath, rule) {
+  ensureDir(path.dirname(filePath));
+  if (fs.existsSync(filePath) && !hasBlock(filePath)) {
+    backupFile(platformId, filePath);
+  }
+  const existing = readSafe(filePath);
+  const block = wrap(rule);
+  const re = new RegExp(`${MARK_BEGIN}[\\s\\S]*?${MARK_END}\\n?`);
+  const next = re.test(existing) ? existing.replace(re, block) : (existing ? `${existing.trim()}\n\n${block}` : block);
+  fs.writeFileSync(filePath, next, 'utf8');
+  return filePath;
+}
+
+function stripBlock(filePath) {
+  const existing = readSafe(filePath);
+  if (!existing) return null;
+  const re = new RegExp(`\\n*${MARK_BEGIN}[\\s\\S]*?${MARK_END}\\n?`);
+  if (!re.test(existing)) return null;
+  const next = existing.replace(re, '').trim();
+  if (next) fs.writeFileSync(filePath, next + '\n', 'utf8');
+  else fs.unlinkSync(filePath);
+  return filePath;
+}
+
+function revertPlatform(platformId) {
+  return restoreAllBackups(platformId);
+}
+
+const PLATFORMS = [
+  {
+    id: 'claude-code',
+    label: 'Claude Code',
+    scope: 'global',
+    detect: (home) => !!process.env.CLAUDE_CONFIG_DIR || dirExists(claudeConfigDir(home)),
+    install: ({ home, rule, id }) => {
+      const rulePath = upsertBlock(id, path.join(claudeConfigDir(home), 'CLAUDE.md'), rule);
+      const hookResult = installHook(home);
+      const cmds = installCommands(home);
+      /* c8 ignore next */
+      const suffixHook = hookResult.settingsMerged ? '+ PreToolUse hook' : `(hook: ${hookResult.note})`;
+      /* c8 ignore next */
+      const suffixCmds = cmds.length ? `+ ${cmds.join(' ')}` : '';
+      return [rulePath, suffixHook, suffixCmds].filter(Boolean).join(' ');
+    },
+    uninstall: ({ home }) => {
+      uninstallHook(home);
+      uninstallCommands(home);
+      return stripBlock(path.join(claudeConfigDir(home), 'CLAUDE.md'));
+    },
+  },
+  {
+    id: 'codex',
+    label: 'Codex CLI',
+    scope: 'global',
+    detect: (home) => dirExists(path.join(home, '.codex')),
+    install: ({ home, rule, id }) => upsertBlock(id, path.join(home, '.codex', 'AGENTS.md'), rule),
+    uninstall: ({ home }) => stripBlock(path.join(home, '.codex', 'AGENTS.md')),
+  },
+  {
+    id: 'cursor',
+    label: 'Cursor (per-repo rule)',
+    scope: 'project',
+    detect: () => fs.existsSync(path.join(process.cwd(), '.cursor')),
+    install: ({ rule, id }) => upsertBlock(id, path.join(process.cwd(), '.cursor', 'rules', 'lakon.mdc'), rule),
+    uninstall: () => stripBlock(path.join(process.cwd(), '.cursor', 'rules', 'lakon.mdc')),
+  },
+  {
+    id: 'windsurf',
+    label: 'Windsurf (per-repo rule)',
+    scope: 'project',
+    detect: () => fs.existsSync(path.join(process.cwd(), '.windsurf')),
+    install: ({ rule, id }) => upsertBlock(id, path.join(process.cwd(), '.windsurf', 'rules', 'lakon.md'), rule),
+    uninstall: () => stripBlock(path.join(process.cwd(), '.windsurf', 'rules', 'lakon.md')),
+  },
+  {
+    id: 'cline',
+    label: 'Cline (per-repo rule)',
+    scope: 'project',
+    detect: () => fs.existsSync(path.join(process.cwd(), '.clinerules')),
+    install: ({ rule, id }) => upsertBlock(id, path.join(process.cwd(), '.clinerules', 'lakon.md'), rule),
+    uninstall: () => stripBlock(path.join(process.cwd(), '.clinerules', 'lakon.md')),
+  },
+  {
+    id: 'gemini',
+    label: 'Gemini CLI',
+    scope: 'global',
+    detect: (home) => dirExists(path.join(home, '.gemini')),
+    install: ({ home, rule, id }) => upsertBlock(id, path.join(home, '.gemini', 'GEMINI.md'), rule),
+    uninstall: ({ home }) => stripBlock(path.join(home, '.gemini', 'GEMINI.md')),
+  },
+];
+
+module.exports = { list: () => PLATFORMS, revertPlatform };

package/src/rules/caveman.md

@@ -0,0 +1,103 @@
+# lakon — terse response style
+
+You are operating in **lakon mode** (named for Lakonía — the region of ancient Sparta whose people gave us the word "laconic"). Respond like a Spartan officer in the field: drop filler words, keep technical content 100% accurate.
+
+## Rules
+
+1. **Drop the preamble.** No "Sure!", "Happy to help", "Great question". Start with the answer.
+2. **No restating.** Don't repeat what the user said. Don't summarize your own answer.
+3. **Sentence fragments are fine.** "Bug in auth middleware. Token check uses `<` not `<=`. Fix:"
+4. **Bullet over prose.** Lists, code, and tables beat paragraphs.
+5. **One short line for what you did.** Not a paragraph. The diff speaks for itself.
+6. **Keep precision.** Identifiers, file paths, line numbers, error messages — verbatim. Never compress these.
+
+## When to drop the style (auto-clarity)
+
+Switch to normal prose for:
+
+- Security warnings or destructive-action confirmations
+- Multi-step instructions where ambiguity could cause harm
+- The user is confused or repeating the same question
+- The user explicitly asks for an explanation
+
+Resume terse mode after.
+
+## Examples
+
+**Don't:**
+> Sure! I'd be happy to help you with that. The reason your React component is re-rendering is likely because you're creating a new object reference on each render cycle. When you pass an inline object as a prop, React's shallow comparison sees it as a different object every time…
+
+**Do:**
+> New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`.
+
+---
+
+**Don't:**
+> I've successfully fixed the bug! I updated the authentication middleware to properly validate the token expiry time. The change was in `src/auth/middleware.ts` on line 42.
+
+**Do:**
+> Fixed. `src/auth/middleware.ts:42` — token check `<` → `<=`.
+
+---
+
+## Shell commands — use the `lakon` prefix
+
+For any shell command whose output you read into context, prefix it with `lakon`. It runs the same command but compresses the output before it reaches you. Same exit code, same behavior — just less to read.
+
+| Use this           | Instead of      |
+|--------------------|-----------------|
+| `lakon git log`    | `git log`       |
+| `lakon git status` | `git status`    |
+| `lakon git diff`   | `git diff`      |
+| `lakon ls -la`     | `ls -la`        |
+| `lakon cat <file>` | `cat <file>`    |
+| `lakon grep -r …`  | `grep -r …`     |
+
+The short alias `lak` works identically: `lak git log`.
+
+Unsupported commands run unchanged through `lakon`, so when in doubt, prefix it.
+
+**Skip the prefix only when:**
+- The user explicitly asks for raw, unfiltered output.
+- You're piping into another command (`git log | head` — pipe `lakon git log | head` instead).
+- You need a specific format the filter would strip (e.g. machine-parseable `git log --format=...`).
+
+## File reads — grep first, then Read with offset/limit
+
+Reading entire files is the single biggest token sink. Before using `Read` on any file:
+
+1. **Don't Read what you don't need.** If you're looking for one symbol or section, `lakon grep -n <pattern> <file>` first. The output gives you line numbers — then `Read` with `offset` and `limit` to fetch only that block.
+2. **Never Read these — grep them or skip:**
+   - `node_modules/**`, `vendor/**`, `dist/**`, `build/**`, `target/**`, `.next/**`, `.turbo/**`, `coverage/**`
+   - Lockfiles: `package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`, `Cargo.lock`, `go.sum`, `*.lock`
+   - Build artifacts: `*.tsbuildinfo`, `*.min.js`, `*.min.css`, source maps, log files, `*.pyc`, `*.so`, `*.class`
+3. **For files > 300 lines:** start with `lakon grep -n` to locate, then `Read` a slice. Don't `Read` a 2000-line file to find one function.
+4. **Use `Glob` to find files**, not `Read` on the directory listing.
+
+These reads cost real context. A `node_modules` peek is 50k tokens of nothing.
+
+## Think in code — for analysis, write a script, don't ingest the data
+
+When the user asks you to **count, filter, parse, compare, or extract** data:
+
+- **Don't** `Read` a 5k-line log and reason about it line by line.
+- **Don't** `Read` a JSON blob and re-summarize it in prose.
+- **Don't** `cat` a CSV and count rows in your head.
+
+**Do** write a one-shot script via `Bash` and consume only its `console.log` output:
+
+```bash
+node -e 'const fs = require("fs"); const lines = fs.readFileSync("app.log", "utf8").split("\n"); console.log(lines.filter(l => l.includes("ERROR")).length)'
+```
+
+```bash
+node -e 'const data = JSON.parse(require("fs").readFileSync("users.json", "utf8")); console.log(data.filter(u => u.role === "admin").map(u => u.email).join("\n"))'
+```
+
+```bash
+awk -F, '$3 > 100 { print $1 }' sales.csv | head -20
+```
+
+The script reads the data; you read only the answer. One script replaces ten tool calls.
+
+This applies whenever you'd otherwise pull bulky input into context just to derive something small from it.

package/src/tracking.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const WEEK_MS = 7 * DAY_MS;
+
+function dataDir() {
+  /* c8 ignore next */
+  return process.env.LAKON_HOME || path.join(os.homedir(), '.lakon');
+}
+
+function logPath() {
+  return path.join(dataDir(), 'log.jsonl');
+}
+
+function record({ cmd, args, rawTokens, filteredTokens }) {
+  if (process.env.LAKON_NO_TRACK === '1') return;
+  try {
+    fs.mkdirSync(dataDir(), { recursive: true });
+    const entry = {
+      t: Date.now(),
+      cmd,
+      args: Array.isArray(args) ? args.slice(0, 4) : [],
+      raw: rawTokens,
+      out: filteredTokens,
+      saved: Math.max(0, rawTokens - filteredTokens),
+    };
+    fs.appendFileSync(logPath(), JSON.stringify(entry) + '\n');
+    /* c8 ignore next 3 */
+  } catch {
+    // never let tracking break a user command
+  }
+}
+
+function readEntries() {
+  try {
+    const raw = fs.readFileSync(logPath(), 'utf8');
+    return raw
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        try { return JSON.parse(line); } catch { return null; }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function isSessionEntry(e) {
+  return e.cmd === 'session';
+}
+
+function aggregate(entries) {
+  const filtered = entries.filter((e) => !isSessionEntry(e));
+  const sum = (xs, k) => xs.reduce((a, e) => a + (e[k] || 0), 0);
+  return {
+    calls: filtered.length,
+    raw: sum(filtered, 'raw'),
+    out: sum(filtered, 'out'),
+    saved: sum(filtered, 'saved'),
+  };
+}
+
+function aggregateSessions(entries) {
+  const sessions = entries.filter(isSessionEntry);
+  const sum = (k) => sessions.reduce((a, e) => a + (e[k] || 0), 0);
+  return {
+    turns: sessions.length,
+    in_tokens: sum('in_tokens'),
+    out_tokens: sum('out_tokens'),
+    cache_read: sum('cache_read'),
+  };
+}
+
+function inWindow(entries, ms) {
+  if (ms === Infinity) return entries;
+  const cutoff = Date.now() - ms;
+  return entries.filter((e) => e.t >= cutoff);
+}
+
+function byWindow(entries, ms) {
+  return aggregate(inWindow(entries, ms));
+}
+
+function byWindowSessions(entries, ms) {
+  return aggregateSessions(inWindow(entries, ms));
+}
+
+function byCommand(entries) {
+  const map = new Map();
+  for (const e of entries) {
+    if (isSessionEntry(e)) continue;
+    const k = e.cmd || 'unknown';
+    if (!map.has(k)) map.set(k, { cmd: k, calls: 0, raw: 0, out: 0, saved: 0 });
+    const acc = map.get(k);
+    acc.calls += 1;
+    acc.raw += e.raw || 0;
+    acc.out += e.out || 0;
+    acc.saved += e.saved || 0;
+  }
+  return [...map.values()].sort((a, b) => b.saved - a.saved);
+}
+
+function pct(saved, raw) {
+  if (!raw) return 0;
+  return Math.round((saved / raw) * 100);
+}
+
+function fmt(n) {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + 'M';
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + 'k';
+  return String(n);
+}
+
+function tok(n) {
+  return fmt(n) + ' tok';
+}
+
+const WINDOW_LABELS = [
+  ['1h ', HOUR_MS],
+  ['24h', DAY_MS],
+  ['7d ', WEEK_MS],
+  ['30d', 30 * DAY_MS],
+  ['all', Infinity],
+];
+
+function useColor() {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.LAKON_COLOR === '0') return false;
+  if (process.env.LAKON_COLOR === '1') return true;
+  return !!process.stdout.isTTY;
+}
+
+function paint(s, codes) {
+  if (!useColor()) return s;
+  return `\x1b[${codes}m${s}\x1b[0m`;
+}
+const dim = (s) => paint(s, '2');
+const bold = (s) => paint(s, '1');
+const green = (s) => paint(s, '32');
+const cyan = (s) => paint(s, '36');
+
+function pad(s, n) {
+  s = String(s);
+  /* c8 ignore next */
+  if (s.length >= n) return s;
+  return s + ' '.repeat(n - s.length);
+}
+function rpad(s, n) {
+  s = String(s);
+  if (s.length >= n) return s;
+  return ' '.repeat(n - s.length) + s;
+}
+
+function report() {
+  const entries = readEntries();
+  if (!entries.length) {
+    return 'lakon: no usage recorded yet. Run a few commands through `lakon` first.\n';
+  }
+
+  const lines = [];
+  const W = byWindow(entries, WEEK_MS);
+  const headlinePct = pct(W.saved, W.raw);
+  lines.push(
+    `${bold('lakon')}  ${dim('— savings this week:')}  ` +
+      `${green(tok(W.saved))} ${dim('saved across')} ${W.calls} ${dim('shell calls')} ${green(`(${headlinePct}%)`)}`
+  );
+  lines.push('');
+
+  lines.push(cyan('shell + read/grep guards') + dim('  (tokens filtered before context)'));
+  lines.push(dim('  win    calls       before          after          saved       %'));
+  for (const [label, ms] of WINDOW_LABELS) {
+    const agg = byWindow(entries, ms);
+    if (agg.calls === 0) continue;
+    const row =
+      `  ${pad(label, 6)}` +
+      `${rpad(agg.calls, 5)}  ` +
+      `${rpad(tok(agg.raw), 12)}  ` +
+      `${rpad(tok(agg.out), 12)}  ` +
+      `${rpad(green(tok(agg.saved)), 12 + (useColor() ? 9 : 0))}  ` +
+      `${rpad(green(pct(agg.saved, agg.raw) + '%'), 4 + (useColor() ? 9 : 0))}`;
+    lines.push(row);
+  }
+
+  const sessionsAll = aggregateSessions(entries);
+  if (sessionsAll.turns > 0) {
+    lines.push('');
+    lines.push(cyan('llm output') + dim('  (model tokens — terse style trims this side)'));
+    lines.push(dim('  win    turns       input         output          cache-read'));
+    for (const [label, ms] of WINDOW_LABELS) {
+      const agg = byWindowSessions(entries, ms);
+      if (agg.turns === 0) continue;
+      const row =
+        `  ${pad(label, 6)}` +
+        `${rpad(agg.turns, 5)}  ` +
+        `${rpad(tok(agg.in_tokens), 12)}  ` +
+        `${rpad(tok(agg.out_tokens), 12)}  ` +
+        `${rpad(tok(agg.cache_read), 12)}`;
+      lines.push(row);
+    }
+  }
+
+  const top = byCommand(entries).slice(0, 5);
+  if (top.length) {
+    lines.push('');
+    lines.push(cyan('top commands') + dim('  (all time)'));
+    for (const c of top) {
+      const row =
+        `  ${pad(c.cmd, 8)}` +
+        `${rpad(c.calls + 'x', 6)}  ` +
+        `${dim('saved')} ${rpad(green(tok(c.saved)), 10 + (useColor() ? 9 : 0))}  ` +
+        `${green(pct(c.saved, c.raw) + '%')}`;
+      lines.push(row);
+    }
+  }
+
+  lines.push('');
+  lines.push(dim(`log: ${logPath()}`));
+  return lines.join('\n') + '\n';
+}
+
+function reset() {
+  try { fs.unlinkSync(logPath()); return true; }
+  catch { return false; }
+}
+
+module.exports = { record, report, reset, readEntries, logPath };