@claudemini/shit-cli 1.0.3

package/lib/log.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+ * shit log — event ingestion dispatcher.
+ * Reads stdin, parses event, delegates to session/extract/report modules.
+ */
+
+import { appendFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { getProjectRoot, getLogDir } from './config.js';
+import { loadState, saveState, processEvent, updateIndex } from './session.js';
+import { extractIntent, extractChanges, classifySession } from './extract.js';
+import { generateReports } from './report.js';
+
+export default async function log(args) {
+  const hookType = args[0] || 'unknown';
+
+  // Read payload from stdin
+  let payload = '';
+  for await (const chunk of process.stdin) {
+    payload += chunk;
+  }
+  if (!payload.trim()) process.exit(0);
+
+  let event;
+  try {
+    event = JSON.parse(payload);
+  } catch {
+    process.exit(1);
+  }
+
+  const projectRoot = getProjectRoot();
+  const logDir = getLogDir(projectRoot);
+  const sessionId = event.session_id || 'unknown';
+  const sessionDir = join(logDir, sessionId);
+  mkdirSync(sessionDir, { recursive: true });
+
+  // 1. Append raw event
+  appendFileSync(join(sessionDir, 'events.jsonl'), payload.trim() + '\n');
+
+  // 2. Load and update state
+  const state = loadState(sessionDir);
+  if (!state) process.exit(1);
+  processEvent(state, event, hookType, projectRoot);
+  saveState(sessionDir, state);
+
+  // 3. Extract semantics and generate reports
+  const intent = extractIntent(state.prompts);
+  const changes = extractChanges(state);
+  const classification = classifySession(intent, changes);
+  generateReports(sessionDir, sessionId, state, intent, changes, classification);
+
+  // 4. On session end: shadow branch + update index
+  if (hookType === 'session-end' || hookType === 'stop') {
+    try {
+      const { commitShadow } = await import('./git-shadow.js');
+      await commitShadow(projectRoot, sessionDir, sessionId);
+    } catch { /* shadow is best-effort */ }
+
+    try {
+      updateIndex(logDir, sessionId, intent, classification, changes, state);
+    } catch { /* index is best-effort */ }
+  }
+
+  process.exit(0);
+}

package/lib/query.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * shit query — cross-session memory queries.
+ * Reads index.json to answer questions about past sessions.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { getProjectRoot, getLogDir } from './config.js';
+
+function loadIndex(logDir) {
+  const indexFile = join(logDir, 'index.json');
+  if (!existsSync(indexFile)) return null;
+  try {
+    return JSON.parse(readFileSync(indexFile, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export default async function query(args) {
+  const logDir = getLogDir(getProjectRoot());
+  const index = loadIndex(logDir);
+
+  if (!index || index.sessions.length === 0) {
+    console.log('No session index found. Sessions are indexed on session-end.');
+    console.log('Run "shit list" to see raw sessions.');
+    return;
+  }
+
+  const jsonOutput = args.includes('--json');
+  const fileArg = args.find(a => a.startsWith('--file='));
+  const recentArg = args.find(a => a.startsWith('--recent='));
+  const typeArg = args.find(a => a.startsWith('--type='));
+  const riskArg = args.find(a => a.startsWith('--risk='));
+
+  let results = [...index.sessions];
+
+  // Filter by file
+  if (fileArg) {
+    const filePath = fileArg.split('=')[1];
+    const sessionIds = index.file_history?.[filePath] || [];
+    if (sessionIds.length === 0) {
+      // Try partial match
+      const matchingFiles = Object.keys(index.file_history || {})
+        .filter(f => f.includes(filePath));
+      const matchedIds = new Set();
+      for (const f of matchingFiles) {
+        for (const id of index.file_history[f]) matchedIds.add(id);
+      }
+      results = results.filter(s => matchedIds.has(s.id));
+      if (matchingFiles.length > 0 && !jsonOutput) {
+        console.log(`Matched files: ${matchingFiles.join(', ')}\n`);
+      }
+    } else {
+      const idSet = new Set(sessionIds);
+      results = results.filter(s => idSet.has(s.id));
+    }
+  }
+
+  // Filter by type
+  if (typeArg) {
+    const type = typeArg.split('=')[1];
+    results = results.filter(s => s.type === type);
+  }
+
+  // Filter by risk
+  if (riskArg) {
+    const risk = riskArg.split('=')[1];
+    results = results.filter(s => s.risk === risk);
+  }
+
+  // Limit by recent
+  if (recentArg) {
+    const n = parseInt(recentArg.split('=')[1]) || 5;
+    results = results.slice(-n);
+  }
+
+  // Output
+  if (jsonOutput) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+
+  if (results.length === 0) {
+    console.log('No matching sessions found.');
+    return;
+  }
+
+  console.log(`${results.length} session(s):\n`);
+  for (const s of results.reverse()) {
+    const filesCount = s.files?.length || 0;
+    console.log(`  ${s.id.slice(0, 8)}  ${s.date}  [${s.type}]  risk:${s.risk}  ${s.duration}min  ${filesCount} files`);
+    if (s.intent) {
+      console.log(`    ${s.intent.slice(0, 100)}`);
+    }
+  }
+
+  // Show file history summary if --file was used
+  if (fileArg) {
+    const filePath = fileArg.split('=')[1];
+    const history = index.file_history?.[filePath];
+    if (history) {
+      console.log(`\nFile "${filePath}" modified in ${history.length} session(s)`);
+    }
+  }
+
+  console.log('\nOptions: --file=<path> --type=<type> --risk=<level> --recent=<n> --json');
+}

package/lib/report.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+/**
+ * Report generation module.
+ * Produces summary.json (v2, bot-readable), summary.txt (human-readable),
+ * prompts.txt, and metadata.json from session state + semantic data.
+ */
+
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Generate all report files for a session.
+ */
+export function generateReports(sessionDir, sessionId, state, intent, changes, classification) {
+  const durationMs = state.start_time && state.last_time
+    ? new Date(state.last_time) - new Date(state.start_time) : 0;
+  const durationMin = Math.round(durationMs / 60000);
+
+  writeSummaryJson(sessionDir, sessionId, state, intent, changes, classification, durationMin);
+  writeSummaryTxt(sessionDir, sessionId, state, intent, changes, classification, durationMin);
+  writePromptsTxt(sessionDir, state);
+  writeMetadataJson(sessionDir, sessionId, state, intent, classification, durationMin);
+}
+
+function writeSummaryJson(sessionDir, sessionId, state, intent, changes, classification, durationMin) {
+  const summary = {
+    version: '2.0',
+    session: {
+      id: sessionId,
+      start: state.start_time,
+      end: state.last_time,
+      duration_minutes: durationMin,
+      type: classification.type,
+      intent: intent.goal,
+      risk: classification.risk,
+      summary: classification.summary,
+    },
+    changes: {
+      files: changes.files
+        .filter(f => f.operations.some(op => op !== 'read'))
+        .map(f => ({
+          path: f.path,
+          category: f.category,
+          operations: f.operations.filter(op => op !== 'read'),
+          editCount: f.editCount,
+          editSummary: f.editSummary,
+        })),
+      summary: changes.summary,
+    },
+    activity: {
+      tools: state.tool_counts,
+      commands: changes.commands,
+      errors: state.errors,
+    },
+    review_hints: {
+      tests_run: classification.reviewHints.testsRun,
+      build_verified: classification.reviewHints.buildVerified,
+      files_without_tests: classification.reviewHints.filesWithoutTests,
+      large_change: classification.reviewHints.largeChange,
+      config_changed: classification.reviewHints.configChanged,
+      migration_added: classification.reviewHints.migrationAdded,
+    },
+    prompts: state.prompts.map(p => typeof p === 'string' ? p : p.text),
+    scope: intent.scope,
+  };
+  writeFileSync(join(sessionDir, 'summary.json'), JSON.stringify(summary, null, 2));
+}
+
+function writeSummaryTxt(sessionDir, sessionId, state, intent, changes, classification, durationMin) {
+  const lines = [];
+
+  // Header
+  lines.push(`# Session: ${sessionId.slice(0, 8)}...`);
+  lines.push(`Type: ${classification.type} | Risk: ${classification.risk} | Duration: ${durationMin}min`);
+  if (classification.summary) {
+    lines.push(`Summary: ${classification.summary}`);
+  }
+  lines.push('');
+
+  // Intent
+  if (intent.goal) {
+    lines.push('## Intent');
+    lines.push(`  Goal: ${intent.goal.slice(0, 200)}`);
+    if (intent.scope.length > 0) {
+      lines.push(`  Scope: ${intent.scope.join(', ')}`);
+    }
+    lines.push('');
+  }
+
+  // Changes
+  const modified = changes.files.filter(f => f.operations.some(op => op !== 'read'));
+  if (modified.length > 0) {
+    lines.push('## Changes');
+    for (const f of modified.slice(0, 20)) {
+      const ops = f.operations.filter(op => op !== 'read').join(',');
+      lines.push(`  [${f.category}] ${f.path} (${ops}${f.editCount > 0 ? ` x${f.editCount}` : ''})`);
+    }
+    if (modified.length > 20) {
+      lines.push(`  ... and ${modified.length - 20} more files`);
+    }
+    lines.push('');
+  }
+
+  // Tools
+  if (Object.keys(state.tool_counts).length > 0) {
+    lines.push('## Tools');
+    Object.entries(state.tool_counts)
+      .sort((a, b) => b[1] - a[1])
+      .forEach(([t, c]) => lines.push(`  ${t}: ${c}`));
+    lines.push('');
+  }
+
+  // Commands by category
+  const cmdEntries = Object.entries(changes.commands).filter(([, cmds]) => cmds.length > 0);
+  if (cmdEntries.length > 0) {
+    lines.push('## Commands');
+    for (const [cat, cmds] of cmdEntries) {
+      lines.push(`  [${cat}] ${cmds.slice(0, 5).join(' | ')}${cmds.length > 5 ? ` (+${cmds.length - 5})` : ''}`);
+    }
+    lines.push('');
+  }
+
+  // Review hints
+  const hints = classification.reviewHints;
+  lines.push('## Review Hints');
+  lines.push(`  Tests run: ${hints.testsRun ? 'YES' : 'NO'}`);
+  lines.push(`  Build verified: ${hints.buildVerified ? 'YES' : 'NO'}`);
+  if (hints.configChanged) lines.push('  WARNING: Config files changed');
+  if (hints.migrationAdded) lines.push('  WARNING: Database migration added');
+  if (hints.largeChange) lines.push('  WARNING: Large change (>10 files)');
+  if (hints.filesWithoutTests.length > 0) {
+    lines.push(`  Files without tests: ${hints.filesWithoutTests.slice(0, 5).join(', ')}`);
+  }
+  lines.push('');
+
+  // Errors
+  if (state.errors.length > 0) {
+    lines.push('## Errors');
+    state.errors.slice(-5).forEach(e => lines.push(`  [${e.tool}] ${(e.message || '').slice(0, 100)}`));
+    lines.push('');
+  }
+
+  // Prompts
+  if (state.prompts.length > 0) {
+    lines.push('## Prompts');
+    state.prompts.forEach(p => {
+      const text = typeof p === 'string' ? p : p.text;
+      lines.push(`  > ${text.slice(0, 120)}`);
+    });
+  }
+
+  writeFileSync(join(sessionDir, 'summary.txt'), lines.join('\n') + '\n');
+}
+
+function writePromptsTxt(sessionDir, state) {
+  if (state.prompts.length > 0) {
+    const promptLines = state.prompts
+      .map(p => {
+        const time = typeof p === 'string' ? '' : p.time;
+        const text = typeof p === 'string' ? p : p.text;
+        return time ? `=== ${time} ===\n${text}\n` : `${text}\n`;
+      })
+      .join('\n');
+    writeFileSync(join(sessionDir, 'prompts.txt'), promptLines);
+  }
+}
+
+function writeMetadataJson(sessionDir, sessionId, state, intent, classification, durationMin) {
+  writeFileSync(join(sessionDir, 'metadata.json'), JSON.stringify({
+    session_id: sessionId,
+    start_time: state.start_time,
+    last_updated: state.last_time,
+    duration_minutes: durationMin,
+    type: classification.type,
+    intent: intent.goal.slice(0, 200),
+    risk: classification.risk,
+    event_count: state.event_count,
+    tool_calls: Object.values(state.tool_counts).reduce((a, b) => a + b, 0),
+    files_touched: state.file_ops.write.length + state.file_ops.edit.length,
+    errors: state.errors.length,
+    scope: intent.scope,
+    last_hook_type: state.last_hook_type,
+  }, null, 2));
+}

package/lib/session.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+/**
+ * Session state management and cross-session index.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { toRelative } from './config.js';
+
+// --- State management ---
+
+const EMPTY_STATE = {
+  start_time: null,
+  last_time: null,
+  event_count: 0,
+  tool_counts: {},
+  file_ops: { read: [], write: [], edit: [], glob: [], grep: [] },
+  commands: [],
+  edits: [],
+  errors: [],
+  prompts: [],
+  last_hook_type: null,
+  shadow_branch: null,
+};
+
+export function loadState(sessionDir) {
+  const stateFile = join(sessionDir, 'state.json');
+  if (!existsSync(stateFile)) {
+    return {
+      ...EMPTY_STATE,
+      file_ops: { read: [], write: [], edit: [], glob: [], grep: [] },
+      commands: [],
+      edits: [],
+      errors: [],
+      prompts: [],
+    };
+  }
+  try {
+    return JSON.parse(readFileSync(stateFile, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function saveState(sessionDir, state) {
+  writeFileSync(join(sessionDir, 'state.json'), JSON.stringify(state, null, 2));
+}
+
+// --- Event processing ---
+
+function addUnique(arr, val) {
+  if (val && !arr.includes(val)) arr.push(val);
+}
+
+export function processEvent(state, event, hookType, projectRoot) {
+  const now = new Date().toISOString();
+  state.event_count++;
+  state.last_hook_type = hookType;
+  state.last_time = now;
+  if (!state.start_time) state.start_time = now;
+
+  const toolName = event.tool_name;
+  const input = event.tool_input || {};
+
+  // User prompts
+  if (hookType === 'user-prompt-submit') {
+    const prompt = event.prompt || event.message || '';
+    if (prompt) state.prompts.push({ time: now, text: prompt });
+    return;
+  }
+
+  // Tool events
+  if (hookType === 'post-tool-use' && toolName) {
+    state.tool_counts[toolName] = (state.tool_counts[toolName] || 0) + 1;
+
+    const rel = (p) => toRelative(projectRoot, p);
+
+    switch (toolName) {
+      case 'Read':
+        addUnique(state.file_ops.read, rel(input.file_path));
+        break;
+      case 'Write':
+        addUnique(state.file_ops.write, rel(input.file_path));
+        break;
+      case 'Edit':
+        addUnique(state.file_ops.edit, rel(input.file_path));
+        if (input.old_string || input.new_string) {
+          state.edits.push({
+            file: rel(input.file_path),
+            old: (input.old_string || '').slice(0, 200),
+            new: (input.new_string || '').slice(0, 200),
+          });
+        }
+        break;
+      case 'Glob':
+        addUnique(state.file_ops.glob, input.pattern);
+        break;
+      case 'Grep':
+        addUnique(state.file_ops.grep, input.pattern);
+        break;
+      case 'Bash':
+        if (input.command) state.commands.push(input.command.slice(0, 500));
+        break;
+    }
+
+    // Track errors
+    const result = event.tool_result;
+    if (result && typeof result === 'object' && result.isError) {
+      state.errors.push({
+        tool: toolName,
+        time: now,
+        message: (typeof result.content === 'string'
+          ? result.content : JSON.stringify(result.content)).slice(0, 300),
+      });
+    }
+  }
+}
+
+// --- Cross-session index ---
+
+export function updateIndex(logDir, sessionId, intent, classification, changes, state) {
+  const indexFile = join(logDir, 'index.json');
+  let index = { project: '', sessions: [], file_history: {} };
+
+  if (existsSync(indexFile)) {
+    try {
+      index = JSON.parse(readFileSync(indexFile, 'utf-8'));
+    } catch { /* start fresh */ }
+  }
+
+  // Detect project name from git or directory
+  if (!index.project) {
+    const parts = logDir.split('/');
+    // logDir is typically <project>/.shit-logs
+    index.project = parts[parts.length - 2] || 'unknown';
+  }
+
+  const durationMs = state.start_time && state.last_time
+    ? new Date(state.last_time) - new Date(state.start_time) : 0;
+  const durationMin = Math.round(durationMs / 60000);
+
+  // Upsert session entry
+  const modifiedFiles = changes.files
+    .filter(f => f.operations.some(op => op !== 'read'))
+    .map(f => f.path);
+
+  const existingIdx = index.sessions.findIndex(s => s.id === sessionId);
+  const sessionEntry = {
+    id: sessionId,
+    date: (state.start_time || new Date().toISOString()).slice(0, 10),
+    type: classification.type,
+    intent: intent.goal.slice(0, 200),
+    files: modifiedFiles,
+    duration: durationMin,
+    risk: classification.risk,
+  };
+
+  if (existingIdx >= 0) {
+    index.sessions[existingIdx] = sessionEntry;
+  } else {
+    index.sessions.push(sessionEntry);
+  }
+
+  // Keep last 100 sessions
+  if (index.sessions.length > 100) {
+    index.sessions = index.sessions.slice(-100);
+  }
+
+  // Update file history
+  if (!index.file_history) index.file_history = {};
+  for (const file of modifiedFiles) {
+    if (!index.file_history[file]) index.file_history[file] = [];
+    if (!index.file_history[file].includes(sessionId)) {
+      index.file_history[file].push(sessionId);
+    }
+    // Keep last 20 sessions per file
+    if (index.file_history[file].length > 20) {
+      index.file_history[file] = index.file_history[file].slice(-20);
+    }
+  }
+
+  writeFileSync(indexFile, JSON.stringify(index, null, 2));
+}

package/lib/shadow.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { getProjectRoot } from './config.js';
+
+export { commitShadow, listShadowBranches, shadowInfo } from './git-shadow.js';
+
+export default async function shadowCmd(args) {
+  const projectRoot = getProjectRoot();
+  const sub = args[0];
+
+  if (sub === 'info' && args[1]) {
+    const { shadowInfo } = await import('./git-shadow.js');
+    const info = shadowInfo(projectRoot, args[1]);
+    if (!info) {
+      console.error(`Branch not found: ${args[1]}`);
+      process.exit(1);
+    }
+    console.log('Recent commits:');
+    console.log(info.log);
+    console.log('\nFiles:');
+    info.files.forEach(f => console.log(`  ${f}`));
+    return;
+  }
+
+  // Default: list shadow branches
+  const { listShadowBranches } = await import('./git-shadow.js');
+  const branches = listShadowBranches(projectRoot);
+
+  if (branches.length === 0) {
+    console.log('No shadow branches found.');
+    console.log('Shadow branches are created on session-end.');
+    return;
+  }
+
+  console.log(`${branches.length} shadow branch(es):\n`);
+  branches.forEach(b => {
+    try {
+      const log = execSync(`git log ${b} --oneline -1`, {
+        cwd: projectRoot, encoding: 'utf-8',
+      }).trim();
+      console.log(`  ${b}  ${log}`);
+    } catch {
+      console.log(`  ${b}`);
+    }
+  });
+
+  console.log('\nUsage:');
+  console.log('  shit shadow info <branch>  # Show branch details');
+  console.log('  git log <branch> --oneline # View commits');
+}

package/lib/view.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { getProjectRoot, getLogDir } from './config.js';
+
+export default async function view(args) {
+  const sessionId = args[0];
+  if (!sessionId) {
+    console.error('Usage: shit view <session-id>');
+    process.exit(1);
+  }
+
+  const logDir = getLogDir(getProjectRoot());
+  const sessionDir = join(logDir, sessionId);
+  if (!existsSync(sessionDir)) {
+    console.error(`Session not found: ${sessionId}`);
+    process.exit(1);
+  }
+
+  // Show summary.txt (contains semantic report)
+  const summaryFile = join(sessionDir, 'summary.txt');
+  if (existsSync(summaryFile)) {
+    console.log(readFileSync(summaryFile, 'utf-8'));
+  }
+
+  // Show summary.json v2 data if --json flag
+  if (args.includes('--json')) {
+    const jsonFile = join(sessionDir, 'summary.json');
+    if (existsSync(jsonFile)) {
+      console.log('\n--- summary.json ---');
+      console.log(readFileSync(jsonFile, 'utf-8'));
+    }
+  }
+
+  // Show shadow branch info
+  const stateFile = join(sessionDir, 'state.json');
+  if (existsSync(stateFile)) {
+    try {
+      const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+      if (state.shadow_branch) {
+        console.log(`\nShadow branch: ${state.shadow_branch}`);
+        console.log(`  git log ${state.shadow_branch} --oneline`);
+        console.log(`  git show ${state.shadow_branch}:.shit-logs/${sessionId}/summary.json`);
+      }
+    } catch { /* ignore */ }
+  }
+
+  console.log(`\nFull logs: ${sessionDir}`);
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@claudemini/shit-cli",
+  "version": "1.0.3",
+  "description": "Session-based Hook Intelligence Tracker - CLI tool for logging Claude Code hooks",
+  "type": "module",
+  "bin": {
+    "shit": "./bin/shit.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "claude-code",
+    "hooks",
+    "logging",
+    "session-tracking"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {}
+}