@claudemini/ses-cli 1.4.3

package/lib/summarize.js

@@ -0,0 +1,315 @@
+#!/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';
+import { SUMMARY_SYSTEM_PROMPT, buildSummarizePrompt } from './prompts.js';
+
+// Default configuration
+const DEFAULT_CONFIG = {
+  provider: 'openai', // or 'anthropic'
+  model: 'gpt-4o-mini',
+  max_tokens: 1000,
+  temperature: 0.7,
+  openai_base_url: 'https://api.openai.com/v1',
+};
+
+/**
+ * Get API configuration from environment or config file
+ */
+export function getApiConfig(projectRoot) {
+  const config = { ...DEFAULT_CONFIG };
+
+  // Check for project config
+  const configFile = join(projectRoot, '.ses-logs', 'config.json');
+  if (existsSync(configFile)) {
+    try {
+      const fileConfig = JSON.parse(readFileSync(configFile, 'utf-8'));
+      Object.assign(config, fileConfig);
+    } catch {
+      // Use defaults
+    }
+  }
+
+  // Environment variables override file config
+  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;
+  }
+
+  if (process.env.OPENAI_BASE_URL) {
+    config.openai_base_url = process.env.OPENAI_BASE_URL;
+  }
+  if (process.env.OPENAI_ENDPOINT) {
+    config.openai_endpoint = process.env.OPENAI_ENDPOINT;
+  }
+  // Universal override for all providers.
+  if (process.env.AI_MODEL) {
+    config.model = process.env.AI_MODEL;
+  }
+
+  // Provider-specific overrides take precedence when applicable.
+  if (config.provider === 'openai' && process.env.OPENAI_MODEL) {
+    config.model = process.env.OPENAI_MODEL;
+  }
+  if (config.provider === 'anthropic' && process.env.ANTHROPIC_MODEL) {
+    config.model = process.env.ANTHROPIC_MODEL;
+  }
+
+  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;
+}
+
+/**
+ * Call OpenAI API
+ */
+function resolveOpenAIEndpoint(config) {
+  const explicitEndpoint = (config.openai_endpoint || '').trim();
+  if (explicitEndpoint) {
+    return explicitEndpoint;
+  }
+
+  const baseUrl = String(config.openai_base_url || DEFAULT_CONFIG.openai_base_url).trim().replace(/\/+$/, '');
+  if (baseUrl.endsWith('/chat/completions')) {
+    return baseUrl;
+  }
+  return `${baseUrl}/chat/completions`;
+}
+
+async function callOpenAI(apiKey, endpoint, model, prompt, maxTokens, temperature) {
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: SUMMARY_SYSTEM_PROMPT },
+        { 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();
+  const msg = data.choices[0].message;
+  // Some OpenAI-compatible providers return reasoning output in `reasoning_content`.
+  return msg.content || msg.reasoning_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 {
+      const openaiEndpoint = resolveOpenAIEndpoint(config);
+      summary = await callOpenAI(
+        config.api_key,
+        openaiEndpoint,
+        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: ses summarize <session-id>');
+    console.log('\nEnvironment variables:');
+    console.log('  OPENAI_API_KEY     # Use OpenAI for summarization');
+    console.log('  OPENAI_BASE_URL    # OpenAI-compatible base URL (e.g. https://api.openai.com/v1)');
+    console.log('  OPENAI_ENDPOINT    # Full OpenAI-compatible endpoint (overrides OPENAI_BASE_URL)');
+    console.log('  AI_MODEL           # Universal model override (applies to all providers)');
+    console.log('  OPENAI_MODEL       # OpenAI-only model override');
+    console.log('  ANTHROPIC_MODEL    # Anthropic-only model override');
+    console.log('  ANTHROPIC_API_KEY  # Use Anthropic for summarization');
+    console.log('\nConfiguration (.ses-logs/config.json):');
+    console.log(`  {"provider": "openai", "model": "gpt-4o-mini", "openai_base_url": "https://api.openai.com/v1"}`);
+    process.exit(1);
+  }
+
+  const sessionDir = join(projectRoot, '.ses-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/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: ses 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}:.ses-logs/${sessionId}/summary.json`);
+      }
+    } catch { /* ignore */ }
+  }
+
+  console.log(`\nFull logs: ${sessionDir}`);
+}

package/lib/webhook.js

@@ -0,0 +1,224 @@
+/**
+ * Webhook support for ses-cli.
+ * Fire-and-forget notifications for session.ended and review.completed events.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { createHmac } from 'crypto';
+import { request as httpsRequest } from 'https';
+import { request as httpRequest } from 'http';
+
+/**
+ * Load webhook configuration from .ses-logs/config.json + environment variables.
+ * Priority (highest wins): process.env > config.json env > config.json webhooks
+ */
+export function loadWebhookConfig(projectRoot) {
+  let fileConfig = {};
+  let configEnv = {};
+  const configPath = join(projectRoot, '.ses-logs', 'config.json');
+  if (existsSync(configPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+      fileConfig = raw.webhooks || {};
+      if (raw.env && typeof raw.env === 'object') {
+        configEnv = raw.env;
+      }
+    } catch { /* ignore malformed config */ }
+  }
+
+  // Resolve: process.env > config.json env > config.json webhooks field
+  const env = (key) => {
+    if (key in process.env) return process.env[key];
+    if (key in configEnv) return configEnv[key];
+    return '';
+  };
+
+  const url = env('SES_WEBHOOK_URL') || fileConfig.url;
+  if (!url) return null;
+
+  const envEvents = env('SES_WEBHOOK_EVENTS');
+  const events = envEvents
+    ? envEvents.split(',').map(e => e.trim()).filter(Boolean)
+    : (Array.isArray(fileConfig.events) ? fileConfig.events : []);
+
+  return {
+    url,
+    events,
+    secret: env('SES_WEBHOOK_SECRET') || fileConfig.secret || '',
+    auth_token: env('SES_WEBHOOK_AUTH_TOKEN') || fileConfig.auth_token || '',
+    headers: fileConfig.headers || {},
+    timeout_ms: fileConfig.timeout_ms || 5000,
+    retry: typeof fileConfig.retry === 'number' ? fileConfig.retry : 1,
+  };
+}
+
+/**
+ * Compute HMAC-SHA256 signature in GitHub-compatible format.
+ */
+function computeSignature(secret, body) {
+  const hmac = createHmac('sha256', secret);
+  hmac.update(body);
+  return `sha256=${hmac.digest('hex')}`;
+}
+
+/**
+ * Send a single HTTP POST request. Returns a promise that resolves/rejects.
+ */
+function httpPost(url, headers, body, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const isHttps = parsed.protocol === 'https:';
+    const reqFn = isHttps ? httpsRequest : httpRequest;
+
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (isHttps ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        ...headers,
+      },
+      timeout: timeoutMs,
+    };
+
+    const req = reqFn(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          resolve({ status: res.statusCode, body: data });
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`Request timed out after ${timeoutMs}ms`));
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * Send webhook for a single config entry. Supports retry.
+ */
+export async function sendWebhook(config, event, payload) {
+  const body = JSON.stringify({
+    event,
+    timestamp: new Date().toISOString(),
+    payload,
+  });
+
+  const headers = { ...config.headers };
+
+  // Auth: HMAC signature or Bearer token (mutually exclusive, HMAC preferred)
+  if (config.secret) {
+    headers['X-Signature-256'] = computeSignature(config.secret, body);
+  } else if (config.auth_token) {
+    headers['Authorization'] = `Bearer ${config.auth_token}`;
+  }
+
+  const maxAttempts = (config.retry || 0) + 1;
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      await httpPost(config.url, headers, body, config.timeout_ms || 5000);
+      return; // success
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxAttempts) {
+        // Brief delay before retry
+        await new Promise(r => setTimeout(r, 500 * attempt));
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Main entry point: load config, filter by event, dispatch webhook.
+ * Non-blocking — logs warnings to stderr, never throws.
+ */
+export async function dispatchWebhook(projectRoot, event, payload) {
+  try {
+    const config = loadWebhookConfig(projectRoot);
+    if (!config) return;
+
+    // If events list is configured, only fire for matching events
+    if (config.events.length > 0 && !config.events.includes(event)) return;
+
+    await sendWebhook(config, event, payload);
+  } catch (err) {
+    process.stderr.write(`[ses-cli] webhook warning: ${err.message}\n`);
+  }
+}
+
+/**
+ * CLI command: ses webhook
+ * Shows current webhook configuration status.
+ */
+export default async function webhook(args) {
+  const { getProjectRoot } = await import('./config.js');
+  const projectRoot = getProjectRoot();
+  const config = loadWebhookConfig(projectRoot);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('Usage: ses webhook [options]');
+    console.log('');
+    console.log('Show current webhook configuration.');
+    console.log('');
+    console.log('Options:');
+    console.log('  --test    Send a test webhook ping');
+    console.log('  --help    Show this help');
+    console.log('');
+    console.log('Configuration (highest priority first):');
+    console.log('  1. Environment variables:');
+    console.log('    SES_WEBHOOK_URL        Webhook endpoint URL');
+    console.log('    SES_WEBHOOK_SECRET     HMAC-SHA256 signing secret');
+    console.log('    SES_WEBHOOK_AUTH_TOKEN  Bearer token');
+    console.log('    SES_WEBHOOK_EVENTS     Comma-separated event list');
+    console.log('  2. .ses-logs/config.json "env" field');
+    console.log('  3. .ses-logs/config.json "webhooks" field');
+    return 0;
+  }
+
+  if (!config) {
+    console.log('No webhook configured.');
+    console.log('');
+    console.log('Set SES_WEBHOOK_URL or add "webhooks" to .ses-logs/config.json');
+    return 0;
+  }
+
+  console.log('Webhook configuration:');
+  console.log(`  URL:     ${config.url}`);
+  console.log(`  Events:  ${config.events.length > 0 ? config.events.join(', ') : '(all)'}`);
+  console.log(`  Auth:    ${config.secret ? 'HMAC-SHA256' : config.auth_token ? 'Bearer token' : 'none'}`);
+  console.log(`  Timeout: ${config.timeout_ms}ms`);
+  console.log(`  Retry:   ${config.retry}`);
+  if (Object.keys(config.headers).length > 0) {
+    console.log(`  Headers: ${Object.keys(config.headers).join(', ')}`);
+  }
+
+  if (args.includes('--test')) {
+    console.log('');
+    console.log('Sending test ping...');
+    try {
+      await sendWebhook(config, 'ping', { message: 'ses-cli webhook test' });
+      console.log('OK — webhook delivered successfully.');
+    } catch (err) {
+      console.error(`Failed: ${err.message}`);
+      return 1;
+    }
+  }
+
+  return 0;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@claudemini/ses-cli",
+  "version": "1.4.3",
+  "description": "Session-based Hook Intelligence Tracker for human-AI coding sessions",
+  "type": "module",
+  "bin": {
+    "ses": "./bin/ses.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --check bin/ses.js && for f in lib/*.js; do node --check \"$f\"; done"
+  },
+  "keywords": [
+    "claude-code",
+    "gemini-cli",
+    "cursor",
+    "ai-coding",
+    "hooks",
+    "session-tracking",
+    "code-review",
+    "checkpoint"
+  ],
+  "homepage": "",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "author": "",
+  "license": "",
+  "dependencies": {
+    "goatchain": "^0.0.29"
+  },
+  "devDependencies": {}
+}