@claudemini/shit-cli 1.2.0 → 1.4.0

package/bin/shit.js

@@ -4,22 +4,25 @@ const args = process.argv.slice(2);
 const command = args[0];
 
 const commands = {
-  enable:     'Enable shit-cli in repository',
-  disable:    'Remove shit-cli hooks',
-  status:     'Show current session status',
-  init:       'Initialize hooks in .claude/settings.json',
-  log:        'Log a hook event (called by hooks)',
-  commit:     'Create checkpoint on git commit (hook)',
-  list:       'List all sessions',
-  checkpoints:'List all checkpoints',
-  view:       'View session details',
-  query:      'Query session memory (cross-session)',
-  rewind:     'Rollback to previous checkpoint',
-  resume:     'Resume session from checkpoint',
-  doctor:     'Fix or clean stuck sessions',
-  shadow:     'List shadow branches',
-  clean:      'Clean old sessions',
-  help:       'Show help',
+  enable:      'Enable shit-cli in repository',
+  disable:     'Remove shit-cli hooks',
+  status:      'Show current session status',
+  init:        'Initialize hooks in .claude/settings.json',
+  log:         'Log a hook event (called by hooks)',
+  commit:      'Create checkpoint on git commit (hook)',
+  list:        'List all sessions',
+  checkpoints: 'List all checkpoints',
+  view:        'View session details',
+  query:       'Query session memory (cross-session)',
+  explain:     'Explain a session or commit',
+  summarize:   'Generate AI summary for a session',
+  rewind:      'Rollback to previous checkpoint',
+  resume:      'Resume session from checkpoint',
+  reset:       'Delete checkpoint for current HEAD',
+  doctor:      'Fix or clean stuck sessions',
+  shadow:      'List shadow branches',
+  clean:       'Clean old sessions',
+  help:        'Show help',
 };
 
 function showHelp() {

package/lib/checkpoint.js

@@ -139,7 +139,9 @@ function buildTree(cwd, dirPath, redact = true) {
  * Commit session checkpoint to shadow branch
  * Branch format: shit/checkpoints/v1/YYYY-MM-DD-<session-id>
  */
-export async function commitCheckpoint(projectRoot, sessionDir, sessionId, commitSha = null) {
+export async function commitCheckpoint(projectRoot, sessionDir, sessionId, commitSha = null, options = {}) {
+  const autoSummarize = options.autoSummarize !== false; // default true
+
   // Verify we're in a git repo
   try {
     git('rev-parse --git-dir', projectRoot);
@@ -212,6 +214,19 @@ export async function commitCheckpoint(projectRoot, sessionDir, sessionId, commi
     commit: commitHash,
     linked_commit: linkedCommit,
   };
+
+  // Auto-summarize if enabled
+  if (autoSummarize) {
+    try {
+      const { summarizeSession } = await import('./summarize.js');
+      const summaryResult = await summarizeSession(projectRoot, sessionId, sessionDir);
+      if (summaryResult.success) {
+        console.log(`✅ AI summary generated: ${summaryResult.model}`);
+      }
+    } catch {
+      // Best effort - summarize is optional
+    }
+  }
 }
 
 /**

package/lib/enable.js

@@ -169,6 +169,11 @@ export default async function enable(args) {
     // Parse arguments
     const agents = [];
     let addCheckpointHook = false;
+    let useLocal = false;
+    let force = false;
+    let pushSessions = true;
+    let telemetry = true;
+    let summarize = true;
 
     for (const arg of args) {
       if (arg === '--all') {
@@ -176,6 +181,20 @@ export default async function enable(args) {
         agents.push(...Object.keys(AGENT_HOOKS));
       } else if (arg === '--checkpoint' || arg === '-c') {
         addCheckpointHook = true;
+      } else if (arg === '--local') {
+        useLocal = true;
+      } else if (arg === '--project') {
+        useLocal = false; // Force project-level settings
+      } else if (arg === '--force' || arg === '-f') {
+        force = true;
+      } else if (arg === '--skip-push-sessions') {
+        pushSessions = false;
+      } else if (arg === '--no-summarize') {
+        summarize = false;
+      } else if (arg.startsWith('--telemetry=')) {
+        telemetry = arg.split('=')[1] !== 'false';
+      } else if (arg === '--telemetry') {
+        telemetry = true;
       } else if (!arg.startsWith('-')) {
         // Assume it's an agent name
         if (AGENT_HOOKS[arg]) {
@@ -193,6 +212,27 @@ export default async function enable(args) {
 
     console.log('🔧 Enabling shit-cli in repository...\n');
 
+    // Write configuration
+    const configData = {
+      enabled: true,
+      push_sessions: pushSessions,
+      summarize: summarize,
+      telemetry: telemetry,
+      log_level: 'info'
+    };
+
+    const settingsFileName = useLocal ? 'settings.local.json' : 'settings.json';
+
+    // Write to .claude/ directory (project or local)
+    const configDir = join(projectRoot, '.claude');
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+
+    const configFile = join(configDir, settingsFileName);
+    writeFileSync(configFile, JSON.stringify(configData, null, 2));
+    console.log(`✅ Wrote configuration: ${configFile}`);
+
     // Setup hooks for each agent
     for (const agent of agents) {
       const settingsFile = setupAgentHooks(projectRoot, agent);
@@ -228,8 +268,13 @@ export default async function enable(args) {
     console.log('  shit checkpoints    # List all checkpoints');
     console.log('  shit commit          # Manually create checkpoint after git commit');
     console.log('\nOptions:');
-    console.log('  --all               # Enable for all supported agents');
+    console.log('  --all                # Enable for all supported agents');
     console.log('  --checkpoint, -c    # Enable automatic checkpoint on git commit');
+    console.log('  --no-summarize       # Disable AI summary generation');
+    console.log('  --skip-push-sessions # Disable auto-push to remote');
+    console.log('  --telemetry=false    # Disable anonymous telemetry');
+    console.log('\nAI Summary:');
+    console.log('  Set OPENAI_API_KEY or ANTHROPIC_API_KEY to enable AI summaries');
 
   } catch (error) {
     console.error('❌ Failed to enable shit-cli:', error.message);

package/lib/explain.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+
+/**
+ * Explain a session or checkpoint
+ * Provides human-readable explanation of what happened in a session
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== '/') {
+    if (existsSync(join(dir, '.git'))) {
+      return dir;
+    }
+    dir = join(dir, '..');
+  }
+  throw new Error('Not in a git repository');
+}
+
+function getSessionData(sessionId, projectRoot) {
+  const sessionDir = join(projectRoot, '.shit-logs', sessionId);
+
+  if (!existsSync(sessionDir)) {
+    return null;
+  }
+
+  const files = {};
+  const fileNames = ['summary.json', 'summary.txt', 'context.md', 'metadata.json'];
+
+  for (const file of fileNames) {
+    const filePath = join(sessionDir, file);
+    if (existsSync(filePath)) {
+      files[file] = readFileSync(filePath, 'utf-8');
+    }
+  }
+
+  return { dir: sessionDir, files };
+}
+
+function explainFromSummary(summaryText) {
+  const lines = summaryText.split('\n');
+  const explanation = [];
+
+  // Extract key information
+  const typeMatch = summaryText.match(/Type:\s*(\w+)/i);
+  const riskMatch = summaryText.match(/Risk:\s*(\w+)/i);
+  const intentMatch = summaryText.match(/Goal:\s*(.+)/i);
+  const durationMatch = summaryText.match(/Duration:\s*(\d+)min/i);
+
+  if (typeMatch) {
+    explanation.push(`📋 Session type: **${typeMatch[1]}**`);
+  }
+
+  if (riskMatch) {
+    const risk = riskMatch[1].toLowerCase();
+    const emoji = risk === 'high' ? '🔴' : risk === 'medium' ? '🟡' : '🟢';
+    explanation.push(`${emoji} Risk level: **${risk}**`);
+  }
+
+  if (intentMatch) {
+    explanation.push(`🎯 Intent: ${intentMatch[1].slice(0, 100)}`);
+  }
+
+  if (durationMatch) {
+    explanation.push(`⏱️  Duration: ${durationMatch[1]} minutes`);
+  }
+
+  // Extract files changed
+  const changesMatch = summaryText.match(/## Changes\n([\s\S]+?)##/);
+  if (changesMatch) {
+    const fileLines = changesMatch[1].split('\n').filter(l => l.trim().startsWith('['));
+    if (fileLines.length > 0) {
+      explanation.push(`\n📝 Files changed (${fileLines.length}):`);
+      fileLines.slice(0, 5).forEach(line => {
+        explanation.push(`   ${line.trim()}`);
+      });
+      if (fileLines.length > 5) {
+        explanation.push(`   ... and ${fileLines.length - 5} more`);
+      }
+    }
+  }
+
+  // Extract tools used
+  const toolsMatch = summaryText.match(/## Tools\n([\s\S]+?)##/);
+  if (toolsMatch) {
+    const toolLines = toolsMatch[1].split('\n').filter(l => l.includes(':'));
+    if (toolLines.length > 0) {
+      explanation.push(`\n🔧 Tools used:`);
+      toolLines.slice(0, 5).forEach(line => {
+        explanation.push(`   ${line.trim()}`);
+      });
+    }
+  }
+
+  // Extract errors
+  if (summaryText.includes('## Errors')) {
+    const errorsMatch = summaryText.match(/## Errors\n([\s\S]+)/);
+    if (errorsMatch && errorsMatch[1].trim()) {
+      explanation.push(`\n⚠️  Errors encountered:`);
+      const errorLines = errorsMatch[1].split('\n').filter(l => l.trim());
+      errorLines.slice(0, 3).forEach(line => {
+        explanation.push(`   ${line.trim()}`);
+      });
+    }
+  }
+
+  return explanation.join('\n');
+}
+
+function explainFromCommit(commitSha, projectRoot) {
+  try {
+    // Try to find associated checkpoint
+    const checkpoints = execSync('git branch --list "shit/checkpoints/v1/*"', {
+      cwd: projectRoot,
+      encoding: 'utf-8'
+    }).split('\n').filter(Boolean);
+
+    for (const branch of checkpoints) {
+      try {
+        const log = execSync(`git log ${branch} --oneline -1`, {
+          cwd: projectRoot,
+          encoding: 'utf-8'
+        }).trim();
+
+        if (log.includes(commitSha.slice(0, 12))) {
+          const message = execSync(`git log ${branch} --format=%B -1`, {
+            cwd: projectRoot,
+            encoding: 'utf-8'
+          }).trim();
+
+          return `📸 This commit has an associated checkpoint:\n\nBranch: ${branch}\n\n${message}`;
+        }
+      } catch {
+        // Skip this branch
+      }
+    }
+
+    return `No checkpoint found for commit ${commitSha}`;
+  } catch {
+    return 'No checkpoint information available';
+  }
+}
+
+export default async function explain(args) {
+  try {
+    const projectRoot = findProjectRoot();
+    const target = args[0];
+
+    if (!target) {
+      console.log('Usage: shit explain <session-id | commit-sha>');
+      console.log('\nExamples:');
+      console.log('  shit explain 2026-02-28-abc12345  # Explain a session');
+      console.log('  shit explain abc1234              # Explain a commit');
+      process.exit(1);
+    }
+
+    console.log(`🔍 Explaining: ${target}\n`);
+
+    // Try to find session first
+    const sessionData = getSessionData(target, projectRoot);
+
+    if (sessionData && sessionData.files['summary.txt']) {
+      console.log('📋 Session Explanation\n');
+      console.log(explainFromSummary(sessionData.files['summary.txt']));
+      console.log('\n---\n💡 Use "shit view ' + target + '" for full details');
+      return;
+    }
+
+    // Try as commit
+    try {
+      execSync('git rev-parse --verify ' + target + '^{commit}', {
+        cwd: projectRoot,
+        stdio: 'ignore'
+      });
+
+      console.log('📸 Commit Explanation\n');
+      console.log(explainFromCommit(target, projectRoot));
+      return;
+    } catch {
+      // Not a commit
+    }
+
+    // Try partial match
+    const sessions = execSync('ls .shit-logs', { cwd: projectRoot, encoding: 'utf-8' })
+      .split('\n')
+      .filter(s => s.includes(target));
+
+    if (sessions.length > 0) {
+      const matchedSession = sessions[0];
+      const data = getSessionData(matchedSession, projectRoot);
+      if (data && data.files['summary.txt']) {
+        console.log('📋 Found session: ' + matchedSession + '\n');
+        console.log(explainFromSummary(data.files['summary.txt']));
+        return;
+      }
+    }
+
+    console.log(`❌ Could not find session or commit: ${target}`);
+
+  } catch (error) {
+    console.error('❌ Failed to explain:', error.message);
+    process.exit(1);
+  }
+}

package/lib/reset.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+/**
+ * Reset - delete checkpoint for current HEAD commit
+ * Similar to 'entire reset' - removes shadow branch and session state
+ */
+
+import { existsSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== '/') {
+    if (existsSync(join(dir, '.git'))) {
+      return dir;
+    }
+    dir = join(dir, '..');
+  }
+  throw new Error('Not in a git repository');
+}
+
+function git(cmd, cwd) {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
+}
+
+function findCheckpointForCommit(projectRoot, commitSha) {
+  try {
+    const branches = git('branch --list "shit/checkpoints/v1/*"', projectRoot)
+      .split('\n')
+      .map(b => b.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
+
+    for (const branch of branches) {
+      try {
+        const log = git(`log ${branch} --oneline -1`, projectRoot);
+        if (log.includes(commitSha.slice(0, 12))) {
+          return branch;
+        }
+      } catch {
+        // Skip
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function findActiveSession(projectRoot) {
+  const shitLogsDir = join(projectRoot, '.shit-logs');
+  if (!existsSync(shitLogsDir)) {
+    return null;
+  }
+
+  const { readdirSync, statSync } = require('fs');
+  const sessions = readdirSync(shitLogsDir)
+    .filter(name => name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/))
+    .map(name => ({
+      name,
+      path: join(shitLogsDir, name),
+      mtime: statSync(join(shitLogsDir, name)).mtime
+    }))
+    .sort((a, b) => b.mtime - a.mtime);
+
+  return sessions.length > 0 ? sessions[0] : null;
+}
+
+export default async function reset(args) {
+  try {
+    const projectRoot = findProjectRoot();
+    const force = args.includes('--force') || args.includes('-f');
+
+    // Get current commit
+    const commitSha = git('rev-parse HEAD', projectRoot);
+    const commitShort = commitSha.slice(0, 12);
+
+    console.log(`🔄 Resetting checkpoint for commit: ${commitShort}\n`);
+
+    // Find checkpoint for this commit
+    const branch = findCheckpointForCommit(projectRoot, commitSha);
+
+    if (!branch) {
+      console.log('ℹ️  No checkpoint found for current commit.');
+      console.log('   Checkpoints are created on git commit, not automatically on session start.');
+      process.exit(0);
+    }
+
+    console.log(`📸 Found checkpoint branch: ${branch}`);
+
+    if (!force) {
+      console.log('\n⚠️  This will delete the checkpoint and its branch.');
+      console.log('   Use --force to proceed without confirmation.');
+      process.exit(1);
+    }
+
+    // Delete the checkpoint branch
+    try {
+      git(`branch -D ${branch}`, projectRoot);
+      console.log(`✅ Deleted checkpoint branch: ${branch}`);
+    } catch {
+      console.log('ℹ️  Branch already deleted or not found');
+    }
+
+    // Optionally clean active session if it's linked to this commit
+    const activeSession = findActiveSession(projectRoot);
+    if (activeSession) {
+      const stateFile = join(activeSession.path, 'state.json');
+      if (existsSync(stateFile)) {
+        try {
+          const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+          if (state.checkpoints && state.checkpoints.some(cp => cp.linked_commit === commitSha)) {
+            // Remove checkpoint references
+            state.checkpoints = state.checkpoints.filter(cp => cp.linked_commit !== commitSha);
+            require('fs').writeFileSync(stateFile, JSON.stringify(state, null, 2));
+            console.log('✅ Updated session state');
+          }
+        } catch {
+          // Best effort
+        }
+      }
+    }
+
+    console.log('\n✅ Reset complete!');
+
+  } catch (error) {
+    console.error('❌ Failed to reset:', error.message);
+    process.exit(1);
+  }
+}

package/lib/summarize.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+/**
+ * AI Summarization module
+ * Automatically generates AI-powered summaries of sessions using LLM APIs
+ * Supports OpenAI and Anthropic APIs
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+// Default configuration
+const DEFAULT_CONFIG = {
+  provider: 'openai', // or 'anthropic'
+  model: 'gpt-4o-mini',
+  max_tokens: 1000,
+  temperature: 0.7,
+};
+
+/**
+ * Get API configuration from environment or config file
+ */
+function getApiConfig(projectRoot) {
+  // Check for environment variables first
+  const config = { ...DEFAULT_CONFIG };
+
+  // OpenAI
+  if (process.env.OPENAI_API_KEY) {
+    config.provider = 'openai';
+    config.api_key = process.env.OPENAI_API_KEY;
+  } else if (process.env.ANTHROPIC_API_KEY) {
+    config.provider = 'anthropic';
+    config.api_key = process.env.ANTHROPIC_API_KEY;
+  }
+
+  // Check for project config
+  const configFile = join(projectRoot, '.shit-logs', 'config.json');
+  if (existsSync(configFile)) {
+    try {
+      const fileConfig = JSON.parse(readFileSync(configFile, 'utf-8'));
+      Object.assign(config, fileConfig);
+    } catch {
+      // Use defaults
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Extract relevant context from session for summarization
+ */
+function extractContext(sessionDir) {
+  const context = {
+    prompts: [],
+    changes: [],
+    tools: {},
+    errors: [],
+    summary: null,
+  };
+
+  // Read summary.json
+  const summaryFile = join(sessionDir, 'summary.json');
+  if (existsSync(summaryFile)) {
+    try {
+      const summary = JSON.parse(readFileSync(summaryFile, 'utf-8'));
+      context.summary = summary;
+      context.prompts = summary.prompts || [];
+      context.tools = summary.activity?.tools || {};
+      context.errors = summary.activity?.errors || [];
+      context.changes = summary.changes?.files || [];
+    } catch {
+      // Best effort
+    }
+  }
+
+  // Read prompts.txt
+  const promptsFile = join(sessionDir, 'prompts.txt');
+  if (existsSync(promptsFile)) {
+    try {
+      context.prompts_text = readFileSync(promptsFile, 'utf-8').slice(0, 3000);
+    } catch {
+      // Best effort
+    }
+  }
+
+  // Read context.md
+  const contextFile = join(sessionDir, 'context.md');
+  if (existsSync(contextFile)) {
+    try {
+      context.context_md = readFileSync(contextFile, 'utf-8').slice(0, 2000);
+    } catch {
+      // Best effort
+    }
+  }
+
+  return context;
+}
+
+/**
+ * Build prompt for LLM summarization
+ */
+function buildSummarizePrompt(context) {
+  const parts = [];
+
+  // System prompt
+  parts.push(`You are a helpful assistant that summarizes AI coding sessions. Generate a concise summary that explains:`);
+  parts.push(`1. What the user wanted to accomplish`);
+  parts.push(`2. What changes were made`);
+  parts.push(`3. Any issues or errors encountered`);
+  parts.push(`4. Overall outcome`);
+
+  parts.push(`\n---\n`);
+
+  // User prompts
+  if (context.prompts_text) {
+    parts.push(`## User Prompts\n${context.prompts_text}\n`);
+  } else if (context.prompts && context.prompts.length > 0) {
+    parts.push(`## User Prompts\n`);
+    context.prompts.slice(0, 5).forEach(p => {
+      const text = typeof p === 'string' ? p : p.text || '';
+      parts.push(`- ${text.slice(0, 200)}`);
+    });
+    parts.push('');
+  }
+
+  // Changes summary
+  if (context.changes && context.changes.length > 0) {
+    parts.push(`## Files Changed\n`);
+    context.changes.slice(0, 10).forEach(f => {
+      const ops = f.operations?.join(', ') || 'modified';
+      parts.push(`- ${f.path}: ${ops}`);
+    });
+    parts.push('');
+  }
+
+  // Tool usage
+  if (context.tools && Object.keys(context.tools).length > 0) {
+    parts.push(`## Tools Used\n`);
+    Object.entries(context.tools).forEach(([tool, count]) => {
+      parts.push(`- ${tool}: ${count} times`);
+    });
+    parts.push('');
+  }
+
+  // Errors
+  if (context.errors && context.errors.length > 0) {
+    parts.push(`## Errors\n`);
+    context.errors.slice(0, 5).forEach(e => {
+      parts.push(`- ${e.tool}: ${(e.message || '').slice(0, 100)}`);
+    });
+    parts.push('');
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Call OpenAI API
+ */
+async function callOpenAI(apiKey, model, prompt, maxTokens, temperature) {
+  const response = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: 'You are a helpful assistant that summarizes AI coding sessions.' },
+        { role: 'user', content: prompt }
+      ],
+      max_tokens: maxTokens,
+      temperature,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+  }
+
+  const data = await response.json();
+  return data.choices[0].message.content;
+}
+
+/**
+ * Call Anthropic API
+ */
+async function callAnthropic(apiKey, model, prompt, maxTokens, temperature) {
+  const response = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      temperature,
+      messages: [
+        { role: 'user', content: prompt }
+      ],
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+  }
+
+  const data = await response.json();
+  return data.content[0].text;
+}
+
+/**
+ * Generate AI summary for a session
+ */
+export async function summarizeSession(projectRoot, sessionId, sessionDir) {
+  const config = getApiConfig(projectRoot);
+
+  if (!config.api_key) {
+    return {
+      success: false,
+      reason: 'No API key configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY environment variable.'
+    };
+  }
+
+  // Extract context from session
+  const context = extractContext(sessionDir);
+
+  // Build prompt
+  const prompt = buildSummarizePrompt(context);
+
+  try {
+    let summary;
+
+    if (config.provider === 'anthropic') {
+      summary = await callAnthropic(
+        config.api_key,
+        config.model || 'claude-3-haiku-20240307',
+        prompt,
+        config.max_tokens,
+        config.temperature
+      );
+    } else {
+      summary = await callOpenAI(
+        config.api_key,
+        config.model || 'gpt-4o-mini',
+        prompt,
+        config.max_tokens,
+        config.temperature
+      );
+    }
+
+    // Save summary
+    const aiSummaryFile = join(sessionDir, 'ai-summary.md');
+    writeFileSync(aiSummaryFile, summary);
+
+    // Update state
+    const stateFile = join(sessionDir, 'state.json');
+    if (existsSync(stateFile)) {
+      try {
+        const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+        state.ai_summary = {
+          provider: config.provider,
+          model: config.model,
+          generated_at: new Date().toISOString(),
+        };
+        writeFileSync(stateFile, JSON.stringify(state, null, 2));
+      } catch {
+        // Best effort
+      }
+    }
+
+    return {
+      success: true,
+      summary,
+      provider: config.provider,
+      model: config.model,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      reason: error.message
+    };
+  }
+}
+
+/**
+ * CLI command for manual summarization
+ */
+export default async function summarize(args) {
+  const projectRoot = findProjectRoot();
+  const sessionId = args[0];
+
+  if (!sessionId) {
+    console.log('Usage: shit summarize <session-id>');
+    console.log('\nEnvironment variables:');
+    console.log('  OPENAI_API_KEY     # Use OpenAI for summarization');
+    console.log('  ANTHROPIC_API_KEY  # Use Anthropic for summarization');
+    console.log('\nConfiguration (.shit-logs/config.json):');
+    console.log(`  {"provider": "openai", "model": "gpt-4o-mini"}`);
+    process.exit(1);
+  }
+
+  const sessionDir = join(projectRoot, '.shit-logs', sessionId);
+
+  if (!existsSync(sessionDir)) {
+    console.error(`Session not found: ${sessionId}`);
+    process.exit(1);
+  }
+
+  console.log(`🤖 Generating AI summary for session: ${sessionId}\n`);
+
+  const result = await summarizeSession(projectRoot, sessionId, sessionDir);
+
+  if (result.success) {
+    console.log('✅ AI Summary generated!\n');
+    console.log(result.summary);
+    console.log(`\n---`);
+    console.log(`Provider: ${result.provider}`);
+    console.log(`Model: ${result.model}`);
+  } else {
+    console.error('❌ Failed to generate summary:', result.reason);
+    process.exit(1);
+  }
+}
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== '/') {
+    if (existsSync(join(dir, '.git'))) {
+      return dir;
+    }
+    dir = join(dir, '..');
+  }
+  throw new Error('Not in a git repository');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudemini/shit-cli",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Session-based Hook Intelligence Tracker - CLI tool for logging Claude Code hooks",
   "type": "module",
   "bin": {