lakonai 0.6.1

package/src/filters/git.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const { stripAnsi, truncateLines } = require('./utils');
+
+const LOG_COMMIT_RE = /^commit\s+([0-9a-f]{7,40})/i;
+const LOG_AUTHOR_RE = /^Author:\s+/i;
+const LOG_DATE_RE = /^Date:\s+/i;
+const STATUS_HEADER_RE = /^(On branch |Your branch |Untracked files:|Changes |\s*\(use "git )/;
+const DIFF_INDEX_RE = /^(index [0-9a-f]+\.\.[0-9a-f]+|diff --git |---|\+\+\+|@@)/;
+
+function filterLog(raw) {
+  const text = stripAnsi(raw);
+  const lines = text.split('\n');
+  const out = [];
+  let pendingHash = null;
+  let captured = false;
+
+  for (const line of lines) {
+    const m = line.match(LOG_COMMIT_RE);
+    if (m) {
+      pendingHash = m[1].slice(0, 7);
+      captured = false;
+      continue;
+    }
+    if (LOG_AUTHOR_RE.test(line) || LOG_DATE_RE.test(line) || line.startsWith('Merge:')) continue;
+    /* c8 ignore next */
+    if (pendingHash && !captured && line.trim() && !line.startsWith(' ')) continue;
+    if (pendingHash && !captured && line.trim()) {
+      out.push(`${pendingHash} ${line.trim()}`);
+      captured = true;
+      pendingHash = null;
+    }
+  }
+  return truncateLines(out.join('\n'), 50);
+}
+
+function filterStatus(raw) {
+  const text = stripAnsi(raw);
+  const lines = text.split('\n');
+  const changed = [];
+  const untracked = [];
+  let mode = null;
+
+  for (const line of lines) {
+    if (line.startsWith('Changes to be committed') || line.startsWith('Changes not staged')) {
+      mode = 'changed';
+      continue;
+    }
+    if (line.startsWith('Untracked files:')) {
+      mode = 'untracked';
+      continue;
+    }
+    if (STATUS_HEADER_RE.test(line)) continue;
+    if (!line.trim()) continue;
+    const cleaned = line.replace(/^\s+/, '').replace(/^\(use.*/, '').trim();
+    /* c8 ignore next */
+    if (!cleaned) continue;
+    if (mode === 'changed') changed.push(cleaned);
+    else if (mode === 'untracked') untracked.push(cleaned);
+  }
+
+  const parts = [];
+  if (changed.length) parts.push(`changed:\n${changed.join('\n')}`);
+  if (untracked.length) parts.push(`untracked:\n${untracked.join('\n')}`);
+  return parts.join('\n\n') || 'clean';
+}
+
+function filterDiff(raw) {
+  const text = stripAnsi(raw);
+  const lines = text.split('\n');
+  const out = [];
+  for (const line of lines) {
+    if (line.startsWith('diff --git ')) {
+      out.push(line);
+      continue;
+    }
+    if (DIFF_INDEX_RE.test(line) && !line.startsWith('@@')) continue;
+    if (line.startsWith('+') || line.startsWith('-') || line.startsWith('@@')) {
+      out.push(line);
+    }
+  }
+  return truncateLines(out.join('\n'), 120);
+}
+
+function filter(subcmd, raw) {
+  switch (subcmd) {
+    case 'log': return filterLog(raw);
+    case 'status': return filterStatus(raw);
+    case 'diff':
+    case 'show': return filterDiff(raw);
+    default: return raw;
+  }
+}
+
+module.exports = { filter, filterLog, filterStatus, filterDiff };

package/src/filters/grep.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { stripAnsi } = require('./utils');
+
+const KEEP_HEAD = 15;
+
+function filter(raw) {
+  const lines = stripAnsi(raw).split('\n').filter(Boolean);
+  if (lines.length <= KEEP_HEAD) return lines.join('\n');
+  const head = lines.slice(0, KEEP_HEAD).join('\n');
+  return `${head}\n… +${lines.length - KEEP_HEAD} more matches (tighten the pattern)`;
+}
+
+module.exports = { filter };

package/src/filters/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const git = require('./git');
+const ls = require('./ls');
+const cat = require('./cat');
+const grep = require('./grep');
+const { countTokensApprox } = require('./utils');
+
+const HANDLERS = {
+  git: (args, raw) => git.filter(args[0], raw),
+  ls: (_args, raw) => ls.filter(raw),
+  tree: (_args, raw) => ls.filter(raw),
+  cat: (_args, raw) => cat.filter(raw),
+  head: (_args, raw) => cat.filter(raw, { maxLines: 50 }),
+  tail: (_args, raw) => cat.filter(raw, { maxLines: 50 }),
+  grep: (_args, raw) => grep.filter(raw),
+  rg: (_args, raw) => grep.filter(raw),
+  ag: (_args, raw) => grep.filter(raw),
+};
+
+function isSupported(cmd) {
+  return Object.prototype.hasOwnProperty.call(HANDLERS, cmd);
+}
+
+function filterCommand(cmd, args, raw) {
+  const handler = HANDLERS[cmd];
+  if (!handler) return raw;
+  try {
+    return handler(args, raw);
+  } catch {
+    return raw;
+  }
+}
+
+module.exports = { filterCommand, isSupported, countTokensApprox, HANDLERS };

package/src/filters/ls.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { stripAnsi, truncateLines } = require('./utils');
+
+const LONG_FORMAT_RE = /^[\-dlcbps][rwx\-]{9}/;
+
+function filterLong(raw) {
+  const lines = stripAnsi(raw).split('\n');
+  const out = [];
+  for (const line of lines) {
+    if (!line.trim() || line.startsWith('total ')) continue;
+    if (LONG_FORMAT_RE.test(line)) {
+      const parts = line.split(/\s+/);
+      const name = parts.slice(8).join(' ');
+      const size = parts[4];
+      if (name) out.push(`${size}\t${name}`);
+    } else {
+      out.push(line);
+    }
+  }
+  return truncateLines(out.join('\n'), 60);
+}
+
+function filter(raw) {
+  const text = stripAnsi(raw);
+  /* c8 ignore next */
+  const firstReal = text.split('\n').find((l) => l.trim() && !/^total\s+\d+/.test(l)) || '';
+  if (LONG_FORMAT_RE.test(firstReal)) {
+    return filterLong(text);
+  }
+  return truncateLines(text, 60);
+}
+
+module.exports = { filter, filterLong };

package/src/filters/utils.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const ANSI_RE = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+
+function stripAnsi(s) {
+  return typeof s === 'string' ? s.replace(ANSI_RE, '') : s;
+}
+
+function truncateLines(text, maxLines, marker) {
+  const lines = text.split('\n');
+  if (lines.length <= maxLines) return text;
+  const kept = lines.slice(0, maxLines).join('\n');
+  const dropped = lines.length - maxLines;
+  const note = marker || `… +${dropped} more lines`;
+  return `${kept}\n${note}`;
+}
+
+function truncateBytes(text, maxBytes, marker) {
+  if (Buffer.byteLength(text, 'utf8') <= maxBytes) return text;
+  const buf = Buffer.from(text, 'utf8').subarray(0, maxBytes);
+  const note = marker || `… truncated at ${maxBytes} bytes`;
+  return `${buf.toString('utf8')}\n${note}`;
+}
+
+function countTokensApprox(text) {
+  return text.split(/\s+/).filter(Boolean).length;
+}
+
+module.exports = { stripAnsi, truncateLines, truncateBytes, countTokensApprox };

package/src/hooks/bash-rewrite.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+'use strict';
+
+const FILTERED_CMDS = new Set([
+  'git', 'ls', 'tree', 'cat', 'head', 'tail', 'grep', 'rg', 'ag',
+]);
+
+function rewriteIfNeeded(command) {
+  if (typeof command !== 'string') return null;
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  if (/^(lakon|lak)(\s|$)/.test(trimmed)) return null;
+  const firstWord = trimmed.split(/\s+/)[0];
+  if (!FILTERED_CMDS.has(firstWord)) return null;
+  return `lakon ${trimmed}`;
+}
+
+async function readStdin() {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) raw += chunk;
+  return raw;
+}
+
+async function main() {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) process.exit(0);
+
+    const data = JSON.parse(raw);
+    if (data.tool_name !== 'Bash') process.exit(0);
+
+    const command = data.tool_input && data.tool_input.command;
+    const rewritten = rewriteIfNeeded(command);
+    if (!rewritten) process.exit(0);
+
+    const response = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'allow',
+        updatedInput: {
+          ...data.tool_input,
+          command: rewritten,
+        },
+      },
+    };
+    process.stdout.write(JSON.stringify(response));
+    process.exit(0);
+  } catch {
+    process.exit(0);
+  }
+}
+
+main();

package/src/hooks/grep-guard.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { shouldEmit } = require('./throttle');
+
+const DEFAULT_HEAD_LIMIT = 30;
+
+function lakonHome() {
+  /* c8 ignore next */
+  return process.env.LAKON_HOME || path.join(os.homedir(), '.lakon');
+}
+
+/* c8 ignore start */
+function trackRecord({ cmd, args, rawTokens, filteredTokens }) {
+  if (process.env.LAKON_NO_TRACK === '1') return;
+  try {
+    const dir = lakonHome();
+    fs.mkdirSync(dir, { 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(path.join(dir, 'log.jsonl'), JSON.stringify(entry) + '\n');
+  } catch {
+    // never let tracking break the hook
+  }
+}
+/* c8 ignore stop */
+
+async function readStdin() {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) raw += chunk;
+  return raw;
+}
+
+/* c8 ignore start */
+async function main() {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) process.exit(0);
+    const data = JSON.parse(raw);
+    if (data.tool_name !== 'Grep') process.exit(0);
+
+    const input = data.tool_input || {};
+    if (input.head_limit != null) process.exit(0);
+
+    const updatedInput = { ...input, head_limit: DEFAULT_HEAD_LIMIT };
+    const reason = shouldEmit('grep-head-cap')
+      ? `lakon: head_limit auto-set to ${DEFAULT_HEAD_LIMIT}. Pass head_limit explicitly to override; pass output_mode:"count" for a tally instead of matches.`
+      : undefined;
+
+    trackRecord({
+      cmd: 'Grep',
+      args: [input.pattern || '', 'cap'],
+      rawTokens: 200,
+      filteredTokens: 50,
+    });
+
+    const response = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'allow',
+        updatedInput,
+        ...(reason ? { permissionDecisionReason: reason } : {}),
+      },
+    };
+    process.stdout.write(JSON.stringify(response));
+    process.exit(0);
+  } catch {
+    process.exit(0);
+  }
+}
+/* c8 ignore stop */
+
+main();

package/src/hooks/read-guard.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function lakonHome() {
+  /* c8 ignore next */
+  return process.env.LAKON_HOME || path.join(os.homedir(), '.lakon');
+}
+
+/* c8 ignore start */
+function trackRecord({ cmd, args, rawTokens, filteredTokens }) {
+  if (process.env.LAKON_NO_TRACK === '1') return;
+  try {
+    const dir = lakonHome();
+    fs.mkdirSync(dir, { 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(path.join(dir, 'log.jsonl'), JSON.stringify(entry) + '\n');
+  } catch {
+    // never let tracking break the hook
+  }
+}
+/* c8 ignore stop */
+
+const DENY_DIRS = [
+  'node_modules',
+  '.next',
+  '.nuxt',
+  'dist',
+  'build',
+  'target',
+  '.turbo',
+  '.cache',
+  'coverage',
+  '__pycache__',
+  '.venv',
+  'venv',
+  'vendor',
+  '.git/objects',
+  '__snapshots__',
+  '.ipynb_checkpoints',
+  '.mypy_cache',
+  '.pytest_cache',
+  '.ruff_cache',
+  '.tox',
+  '.svelte-kit',
+  '.parcel-cache',
+  '.vercel',
+  'tmp',
+  'cypress/screenshots',
+  'cypress/videos',
+  'playwright-report',
+  'test-results',
+  '.idea',
+  '.vscode',
+];
+
+const DENY_FILE_RE = /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lock(b)?|Cargo\.lock|Gemfile\.lock|composer\.lock|poetry\.lock|uv\.lock|go\.sum|.*\.tsbuildinfo|.*\.log|.*\.min\.(js|css|mjs)|.*\.map|.*\.pyc|.*\.pyo|.*\.so|.*\.o|.*\.a|.*\.dylib|.*\.dll|.*\.exe|.*\.class|.*\.wasm)$/;
+
+const AUTO_CAP_LINES = 800;
+
+function isDeniedPath(p) {
+  /* c8 ignore next */
+  if (typeof p !== 'string' || !p) return null;
+  const norm = p.replace(/\\/g, '/');
+  for (const dir of DENY_DIRS) {
+    if (norm.includes(`/${dir}/`) || norm.endsWith(`/${dir}`) || norm.startsWith(`${dir}/`)) {
+      return `path lives under ${dir}/ — read costs context for noise. grep -n the symbol instead, then Read with offset/limit.`;
+    }
+  }
+  if (DENY_FILE_RE.test(norm)) {
+    return 'lockfile/build artifact — almost never useful for the agent. grep -n the symbol inside if you must.';
+  }
+  return null;
+}
+
+function fileLineCount(p) {
+  try {
+    const data = fs.readFileSync(p, 'utf8');
+    let n = 0;
+    for (let i = 0; i < data.length; i++) if (data.charCodeAt(i) === 10) n++;
+    if (data.length && data.charCodeAt(data.length - 1) !== 10) n++;
+    return n;
+    /* c8 ignore next 3 */
+  } catch {
+    return null;
+  }
+}
+
+function estimateTokensByBytes(p) {
+  try {
+    const size = fs.statSync(p).size;
+    return Math.max(1, Math.round(size / 4));
+  } catch {
+    return 0;
+  }
+}
+
+async function readStdin() {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) raw += chunk;
+  return raw;
+}
+
+/* c8 ignore start */
+async function main() {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) process.exit(0);
+    const data = JSON.parse(raw);
+    if (data.tool_name !== 'Read') process.exit(0);
+
+    const input = data.tool_input || {};
+    const fp = input.file_path;
+    if (typeof fp !== 'string' || !fp) process.exit(0);
+
+    const denyReason = isDeniedPath(fp);
+    if (denyReason) {
+      const rawTokens = estimateTokensByBytes(fp);
+      trackRecord({
+        cmd: 'Read',
+        args: [fp, 'deny'],
+        rawTokens,
+        filteredTokens: 0,
+      });
+      const response = {
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: `lakon: ${denyReason}`,
+        },
+      };
+      process.stdout.write(JSON.stringify(response));
+      process.exit(0);
+    }
+
+    if (input.limit == null && input.offset == null) {
+      const n = fileLineCount(fp);
+      if (n !== null && n > AUTO_CAP_LINES) {
+        const rawTokens = estimateTokensByBytes(fp);
+        const capRatio = AUTO_CAP_LINES / n;
+        const filteredTokens = Math.round(rawTokens * capRatio);
+        trackRecord({
+          cmd: 'Read',
+          args: [fp, 'cap'],
+          rawTokens,
+          filteredTokens,
+        });
+        const response = {
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'allow',
+            updatedInput: {
+              ...input,
+              offset: 1,
+              limit: AUTO_CAP_LINES,
+            },
+            permissionDecisionReason: `lakon: file has ${n} lines, capped at ${AUTO_CAP_LINES}. Read again with offset=${AUTO_CAP_LINES + 1} for more, or grep -n the symbol you need.`,
+          },
+        };
+        process.stdout.write(JSON.stringify(response));
+        process.exit(0);
+      }
+    }
+
+    process.exit(0);
+  } catch {
+    process.exit(0);
+  }
+}
+/* c8 ignore stop */
+
+main();

package/src/hooks/session-start.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+'use strict';
+
+const { checkForUpdate, formatNotice } = require('./version-check');
+
+async function readStdin() {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) raw += chunk;
+  return raw;
+}
+
+async function main() {
+  try {
+    await readStdin();
+    const update = await checkForUpdate();
+    if (!update) process.exit(0);
+
+    const response = {
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext: formatNotice(update),
+      },
+    };
+    process.stdout.write(JSON.stringify(response));
+    process.exit(0);
+    /* c8 ignore next 3 */
+  } catch {
+    process.exit(0);
+  }
+}
+
+main();

package/src/hooks/stop-hook.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function lakonHome() {
+  /* c8 ignore next */
+  return process.env.LAKON_HOME || path.join(os.homedir(), '.lakon');
+}
+
+/* c8 ignore start */
+function trackSession(payload) {
+  if (process.env.LAKON_NO_TRACK === '1') return;
+  try {
+    const dir = lakonHome();
+    fs.mkdirSync(dir, { recursive: true });
+    const entry = { t: Date.now(), cmd: 'session', ...payload };
+    fs.appendFileSync(path.join(dir, 'log.jsonl'), JSON.stringify(entry) + '\n');
+  } catch {
+    // never let tracking break the hook
+  }
+}
+/* c8 ignore stop */
+
+async function readStdin() {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) raw += chunk;
+  return raw;
+}
+
+function extractUsage(transcriptPath) {
+  try {
+    const content = fs.readFileSync(transcriptPath, 'utf8');
+    const lines = content.split('\n').filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const obj = JSON.parse(lines[i]);
+        const msg = obj.message;
+        if (msg && msg.role === 'assistant' && msg.usage) {
+          return {
+            /* c8 ignore next 2 */
+            in_tokens: msg.usage.input_tokens || 0,
+            out_tokens: msg.usage.output_tokens || 0,
+            cache_read: msg.usage.cache_read_input_tokens || 0,
+            cache_create: msg.usage.cache_creation_input_tokens || 0,
+          };
+        }
+      } catch {
+        // skip malformed lines
+      }
+    }
+    /* c8 ignore next 3 */
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+/* c8 ignore start */
+async function main() {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) process.exit(0);
+    const data = JSON.parse(raw);
+    if (!data.transcript_path) process.exit(0);
+
+    const usage = extractUsage(data.transcript_path);
+    if (!usage) process.exit(0);
+
+    trackSession({
+      session_id: data.session_id || null,
+      ...usage,
+    });
+    process.exit(0);
+  } catch {
+    process.exit(0);
+  }
+}
+/* c8 ignore stop */
+
+main();

package/src/hooks/throttle.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/* c8 ignore next */
+const MARKER_DIR = path.join(os.tmpdir(), `lakon-${process.env.USER || 'session'}`);
+const TTL_MS = 4 * 60 * 60 * 1000;
+
+/* c8 ignore start */
+function shouldEmit(category) {
+  if (process.env.LAKON_NO_THROTTLE === '1') return true;
+  try {
+    fs.mkdirSync(MARKER_DIR, { recursive: true });
+    const marker = path.join(MARKER_DIR, `${category}.marker`);
+    try {
+      const st = fs.statSync(marker);
+      if (Date.now() - st.mtimeMs < TTL_MS) return false;
+    } catch {
+      /* not yet emitted */
+    }
+    const fd = fs.openSync(marker, fs.constants.O_CREAT | fs.constants.O_WRONLY | fs.constants.O_TRUNC);
+    fs.closeSync(fd);
+    return true;
+  } catch {
+    return true;
+  }
+}
+/* c8 ignore stop */
+
+module.exports = { shouldEmit };