@claudemini/shit-cli 1.3.0 → 1.5.0

package/lib/rewind.js

@@ -5,54 +5,71 @@
  * Similar to 'entire rewind' - rollback to known good state
  */
 
-import { existsSync, readFileSync, writeFileSync } 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');
-}
+import { getProjectRoot } from './config.js';
 
 function git(cmd, cwd) {
   return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
 }
 
+function parseCheckpointRef(projectRoot, branch) {
+  const shadowMatch = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
+  if (shadowMatch) {
+    return {
+      type: 'shadow',
+      baseCommit: shadowMatch[1],
+      sessionShort: shadowMatch[2],
+      lookupKey: shadowMatch[2],
+    };
+  }
+
+  const checkpointMatch = branch.match(/^shit\/checkpoints\/v1\/(\d{4}-\d{2}-\d{2})-([a-f0-9]+)$/);
+  if (checkpointMatch) {
+    const message = git(`log ${branch} --format=%B -1`, projectRoot);
+    const linkedMatch = message.match(/@ ([a-f0-9]+)/);
+    const date = checkpointMatch[1];
+    const sessionShort = checkpointMatch[2];
+    return {
+      type: 'checkpoint',
+      baseCommit: linkedMatch ? linkedMatch[1] : null,
+      sessionShort,
+      lookupKey: `${date}-${sessionShort}`,
+    };
+  }
+
+  return null;
+}
+
 function listCheckpoints(projectRoot) {
   try {
-    // Get shadow branches
-    const branches = git('branch --list "shit/*"', projectRoot)
+    const branches = git('branch --list "shit/checkpoints/v1/*" "shit/*"', projectRoot)
       .split('\n')
       .map(b => b.trim().replace(/^\*?\s*/, ''))
       .filter(Boolean);
+    const uniqueBranches = [...new Set(branches)];
 
     const checkpoints = [];
 
-    for (const branch of branches) {
+    for (const branch of uniqueBranches) {
       try {
+        const parsed = parseCheckpointRef(projectRoot, branch);
+        if (!parsed) {
+          continue;
+        }
+
         const log = git(`log ${branch} --oneline -1`, projectRoot);
         const [commit, ...messageParts] = log.split(' ');
         const message = messageParts.join(' ');
-
-        // Extract session info from branch name: shit/<commit>-<session>
-        const match = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
-        if (match) {
-          const [, baseCommit, sessionShort] = match;
-          checkpoints.push({
-            branch,
-            commit,
-            baseCommit,
-            sessionShort,
-            message,
-            timestamp: git(`log ${branch} --format=%ci -1`, projectRoot)
-          });
-        }
+        checkpoints.push({
+          branch,
+          commit,
+          baseCommit: parsed.baseCommit,
+          sessionShort: parsed.sessionShort,
+          lookupKey: parsed.lookupKey,
+          type: parsed.type,
+          message,
+          timestamp: git(`log ${branch} --format=%ci -1`, projectRoot)
+        });
       } catch {
         // Skip invalid branches
       }
@@ -84,6 +101,10 @@ function hasUncommittedChanges(projectRoot) {
 function rewindToCheckpoint(projectRoot, checkpoint, force = false) {
   const currentCommit = getCurrentCommit(projectRoot);
 
+  if (!checkpoint.baseCommit) {
+    throw new Error(`Checkpoint ${checkpoint.lookupKey || checkpoint.sessionShort} is missing a linked base commit`);
+  }
+
   if (!force && hasUncommittedChanges(projectRoot)) {
     throw new Error('Working directory has uncommitted changes. Use --force to override or commit changes first.');
   }
@@ -100,7 +121,7 @@ function rewindToCheckpoint(projectRoot, checkpoint, force = false) {
 
 export default async function rewind(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const force = args.includes('--force') || args.includes('-f');
     const interactive = args.includes('--interactive') || args.includes('-i');
 
@@ -112,7 +133,7 @@ export default async function rewind(args) {
 
     if (checkpoints.length === 0) {
       console.log('❌ No checkpoints found');
-      console.log('   Checkpoints are created automatically when sessions end.');
+      console.log('   Checkpoints are created when you run "shit commit".');
       process.exit(1);
     }
 
@@ -120,7 +141,8 @@ export default async function rewind(args) {
       // Find specific checkpoint
       targetCheckpoint = checkpoints.find(cp =>
         cp.sessionShort.startsWith(checkpointArg) ||
-        cp.baseCommit.startsWith(checkpointArg)
+        cp.lookupKey.startsWith(checkpointArg) ||
+        (cp.baseCommit && cp.baseCommit.startsWith(checkpointArg))
       );
 
       if (!targetCheckpoint) {
@@ -132,22 +154,25 @@ export default async function rewind(args) {
       console.log('📋 Available checkpoints:\n');
       checkpoints.forEach((cp, i) => {
         const date = new Date(cp.timestamp).toLocaleString();
-        console.log(`${i + 1}. ${cp.sessionShort} (${cp.baseCommit.slice(0, 7)}) - ${date}`);
+        const base = cp.baseCommit ? cp.baseCommit.slice(0, 7) : 'unknown';
+        const key = cp.lookupKey || cp.sessionShort;
+        console.log(`${i + 1}. ${key} (${base}) - ${date}`);
         console.log(`   ${cp.message}`);
         console.log();
       });
 
       // For now, just use the most recent
       targetCheckpoint = checkpoints[0];
-      console.log(`Using most recent checkpoint: ${targetCheckpoint.sessionShort}`);
+      console.log(`Using most recent checkpoint: ${targetCheckpoint.lookupKey || targetCheckpoint.sessionShort}`);
     } else {
       // Use most recent checkpoint
       targetCheckpoint = checkpoints[0];
     }
 
-    console.log(`🔄 Rewinding to checkpoint: ${targetCheckpoint.sessionShort}`);
+    const selectedKey = targetCheckpoint.lookupKey || targetCheckpoint.sessionShort;
+    console.log(`🔄 Rewinding to checkpoint: ${selectedKey}`);
     console.log(`   Branch: ${targetCheckpoint.branch}`);
-    console.log(`   Base commit: ${targetCheckpoint.baseCommit}`);
+    console.log(`   Base commit: ${targetCheckpoint.baseCommit || 'unknown'}`);
     console.log(`   Created: ${new Date(targetCheckpoint.timestamp).toLocaleString()}`);
     console.log();
 
@@ -164,7 +189,7 @@ export default async function rewind(args) {
     console.log(`   git reset --hard ${previousCommit}`);
     console.log();
     console.log('💡 To resume from this checkpoint:');
-    console.log(`   shit resume ${targetCheckpoint.sessionShort}`);
+    console.log(`   shit resume ${selectedKey}`);
 
   } catch (error) {
     console.error('❌ Failed to rewind:', error.message);

package/lib/session.js

@@ -105,6 +105,12 @@ export function processEvent(state, event, hookType, projectRoot) {
     return;
   }
 
+  // Mark session as ended for end/stop hooks.
+  if (hookType === 'session-end' || hookType === 'SessionEnd' || hookType === 'stop' || hookType === 'session_end' || hookType === 'end') {
+    state.end_time = now;
+    return;
+  }
+
   // Tool events
   if (hookType === 'post-tool-use' && toolName) {
     state.tool_counts[toolName] = (state.tool_counts[toolName] || 0) + 1;

package/lib/status.js

@@ -5,20 +5,10 @@
  * Similar to 'entire status' - displays active session info
  */
 
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync } 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');
-}
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
 
 function getCurrentSession(projectRoot) {
   const shitLogsDir = join(projectRoot, '.shit-logs');
@@ -27,9 +17,11 @@ function getCurrentSession(projectRoot) {
   }
 
   // Find the most recent session directory
-  const { readdirSync, statSync } = await import('fs');
   const sessions = readdirSync(shitLogsDir)
-    .filter(name => name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/)) // session format
+    .filter(name => {
+      const fullPath = join(shitLogsDir, name);
+      return SESSION_ID_REGEX.test(name) && statSync(fullPath).isDirectory();
+    })
     .map(name => ({
       name,
       path: join(shitLogsDir, name),
@@ -90,11 +82,45 @@ function formatDuration(startTime) {
   }
 }
 
+function getTouchedFileCount(state) {
+  const ops = state?.file_ops;
+  if (!ops || typeof ops !== 'object') {
+    return 0;
+  }
+
+  const touched = new Set([
+    ...(Array.isArray(ops.write) ? ops.write : []),
+    ...(Array.isArray(ops.edit) ? ops.edit : []),
+    ...(Array.isArray(ops.read) ? ops.read : []),
+  ].filter(Boolean));
+
+  return touched.size;
+}
+
+function hasShitHooks(settings) {
+  if (!settings?.hooks || typeof settings.hooks !== 'object') {
+    return false;
+  }
+
+  return Object.values(settings.hooks).some(value => {
+    if (typeof value === 'string') {
+      return value.includes('shit log');
+    }
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    return value.some(entry =>
+      Array.isArray(entry?.hooks) &&
+      entry.hooks.some(hook => typeof hook?.command === 'string' && hook.command.includes('shit log'))
+    );
+  });
+}
+
 export default async function status(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const gitInfo = getGitInfo(projectRoot);
-    const currentSession = await getCurrentSession(projectRoot);
+    const currentSession = getCurrentSession(projectRoot);
 
     console.log('📊 shit-cli Status\n');
 
@@ -121,7 +147,7 @@ export default async function status(args) {
         console.log(`   Started: ${new Date(state.start_time).toLocaleString()}`);
         console.log(`   Duration: ${formatDuration(state.start_time)}`);
         console.log(`   Events: ${state.event_count || 0}`);
-        console.log(`   Files: ${Object.keys(state.files || {}).length}`);
+        console.log(`   Files: ${getTouchedFileCount(state)}`);
 
         if (state.shadow_branch) {
           console.log(`   Shadow: ${state.shadow_branch}`);
@@ -149,8 +175,7 @@ export default async function status(args) {
     if (existsSync(claudeSettings)) {
       try {
         const settings = JSON.parse(readFileSync(claudeSettings, 'utf-8'));
-        const hasHooks = settings.hooks &&
-          (settings.hooks.session_start || settings.hooks.session_end);
+        const hasHooks = hasShitHooks(settings);
 
         console.log();
         if (hasHooks) {

package/lib/summarize.js

@@ -0,0 +1,331 @@
+#!/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 { getProjectRoot } from './config.js';
+
+// 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 = getProjectRoot();
+  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);
+  }
+}

package/package.json

@@ -1,20 +1,37 @@
 {
   "name": "@claudemini/shit-cli",
-  "version": "1.3.0",
-  "description": "Session-based Hook Intelligence Tracker - CLI tool for logging Claude Code hooks",
+  "version": "1.5.0",
+  "description": "Session-based Hook Intelligence Tracker - Zero-dependency memory system for human-AI coding sessions",
   "type": "module",
   "bin": {
     "shit": "./bin/shit.js"
   },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
     "claude-code",
+    "gemini-cli",
+    "cursor",
+    "ai-coding",
     "hooks",
-    "logging",
-    "session-tracking"
+    "session-tracking",
+    "code-review",
+    "checkpoint"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anthropics/shit-cli.git"
+  },
   "author": "",
   "license": "MIT",
   "dependencies": {},