ai-cli-log 1.0.3 → 1.0.5

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -32,87 +33,383 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const pty = __importStar(require("node-pty"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
 const headless_1 = require("@xterm/headless");
-const args = process.argv.slice(2);
-const command = args[0];
-const commandArgs = args.slice(1);
-if (!command) {
-    console.error('Usage: ai-cli-log <command> [args...]');
-    process.exit(1);
+const readline_1 = __importDefault(require("readline"));
+// --- 1. CONFIGURATION & TYPE DEFINITIONS ---
+const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.config', 'ai-cli-log');
+const GLOBAL_CONFIG_PATH = path.join(GLOBAL_CONFIG_DIR, 'config.json');
+const LOCAL_CONFIG_PATH = path.join(process.cwd(), '.ai-cli-log', 'config.json');
+function findConfigPath() {
+    if (fs.existsSync(LOCAL_CONFIG_PATH))
+        return LOCAL_CONFIG_PATH;
+    if (fs.existsSync(GLOBAL_CONFIG_PATH))
+        return GLOBAL_CONFIG_PATH;
+    return null;
 }
-const logsDir = path.join(process.cwd(), '.ai-cli-logs');
-if (!fs.existsSync(logsDir)) {
-    fs.mkdirSync(logsDir);
+function readConfig() {
+    const configPath = findConfigPath();
+    if (!configPath)
+        return { summarizer: { summarizers: [] } };
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.error(`Error reading or parsing config file at ${configPath}:`, error);
+        return { summarizer: { summarizers: [] } };
+    }
 }
-// Initialize xterm.js in headless mode
-const xterm = new headless_1.Terminal({
-    rows: process.stdout.rows,
-    cols: process.stdout.columns,
-    scrollback: Infinity, // Set scrollback to Infinity for unlimited buffer
-    allowProposedApi: true,
-});
-const term = pty.spawn(command, commandArgs, {
-    name: 'xterm-color',
-    cols: process.stdout.columns,
-    rows: process.stdout.rows,
-    cwd: process.cwd(),
-    env: process.env,
-});
-// Pipe pty output to xterm.js and also to stdout
-term.onData((data) => {
-    process.stdout.write(data);
-    xterm.write(data);
-});
-// Pipe stdin to pty
-process.stdin.on('data', (data) => {
-    term.write(data.toString());
-});
-process.stdin.setRawMode(true);
-process.stdin.resume();
-term.onExit(({ exitCode, signal }) => {
-    // Add a small delay to ensure xterm.js has processed all output
-    setTimeout(() => {
-        // Extract rendered text from xterm.js buffer
-        let renderedOutput = '';
-        // Iterate over the entire buffer, including scrollback.
-        // The total number of lines is the sum of lines in scrollback (baseY) and visible rows.
-        for (let i = 0; i < xterm.buffer.active.baseY + xterm.rows; i++) {
-            const line = xterm.buffer.active.getLine(i);
-            if (line) {
-                // translateToString(true) gets the line content, and we trim trailing whitespace.
-                const lineText = line.translateToString(true).replace(/\s+$/, '');
-                renderedOutput += lineText + '\n';
+function writeConfig(config, isLocal) {
+    const targetPath = isLocal ? LOCAL_CONFIG_PATH : GLOBAL_CONFIG_PATH;
+    const targetDir = path.dirname(targetPath);
+    try {
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir, { recursive: true });
+        }
+        fs.writeFileSync(targetPath, JSON.stringify(config, null, 2));
+        console.log(`✔ Configuration successfully saved to ${targetPath}`);
+    }
+    catch (error) {
+        console.error(`Error writing config file to ${targetPath}:`, error);
+    }
+}
+// --- 2. COMMAND IMPLEMENTATIONS ---
+async function handleInitCommand(isLocal) {
+    const targetPath = isLocal ? LOCAL_CONFIG_PATH : GLOBAL_CONFIG_PATH;
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (question) => new Promise(resolve => rl.question(question, resolve));
+    try {
+        if (fs.existsSync(targetPath)) {
+            const warning = `Configuration file already exists. Continuing will allow you to add or update default summarizers (gemini-pro, ollama, sgpt) with the latest recommended settings, while preserving any other custom summarizers you have added.`;
+            console.log(warning);
+            const answer = await ask('Do you want to continue? (y/N): ');
+            if (answer.toLowerCase() !== 'y') {
+                console.log('Initialization cancelled.');
+                return;
             }
         }
-        const now = new Date();
-        const year = now.getFullYear();
-        const month = (now.getMonth() + 1).toString().padStart(2, '0');
-        const day = now.getDate().toString().padStart(2, '0');
-        const hours = now.getHours().toString().padStart(2, '0');
-        const minutes = now.getMinutes().toString().padStart(2, '0');
-        const seconds = now.getSeconds().toString().padStart(2, '0');
-        const prefix = command || 'session';
-        const logFileName = `${prefix}-${year}${month}${day}-${hours}${minutes}${seconds}.md`;
-        const logFilePath = path.join(logsDir, logFileName);
-        fs.writeFile(logFilePath, renderedOutput, (err) => {
-            if (err) {
-                console.error('Error writing log file:', err);
+        console.log('\nScanning for available AI tools...');
+        const availableTools = [];
+        const checkTool = (tool) => new Promise(resolve => {
+            const proc = (0, child_process_1.spawn)('which', [tool], { stdio: 'ignore' });
+            proc.on('close', code => {
+                if (code === 0) {
+                    console.log(`  - Found ${tool}!`);
+                    availableTools.push(tool);
+                }
+                resolve();
+            });
+            proc.on('error', () => resolve());
+        });
+        await Promise.all([checkTool('gemini'), checkTool('ollama'), checkTool('sgpt'), checkTool('claude')]);
+        if (availableTools.length === 0) {
+            console.log('No supported AI tools (gemini, ollama, sgpt, claude) found in your PATH.');
+            const createEmpty = await ask('\n> Would you like to create an empty configuration file to manually add a custom summarizer? (y/N): ');
+            if (createEmpty.toLowerCase() === 'y') {
+                const config = readConfig(); // Read to not overwrite existing unrelated config
+                writeConfig(config, isLocal);
             }
             else {
-                console.log(`Session logged to ${path.relative(process.cwd(), logFilePath)}`);
+                console.log('Initialization cancelled.');
+            }
+            return;
+        }
+        const config = readConfig();
+        const summarizersToUpdate = [];
+        const newPrompt = 'You are a log summarizer. Your response MUST be a valid JSON object with one key: "summary" (a 3-5 word, lowercase, filename-friendly phrase). Example: {"summary": "refactor-database-schema"}. The session content is:';
+        if (availableTools.includes('gemini')) {
+            const add = await ask('\n> Found Gemini. Add/update the \'gemini-pro\' summarizer? (Y/n): ');
+            if (add.toLowerCase() !== 'n') {
+                summarizersToUpdate.push({
+                    name: 'gemini-pro',
+                    tool: 'gemini',
+                    prompt: newPrompt,
+                    maxLines: 100,
+                });
+            }
+        }
+        if (availableTools.includes('ollama')) {
+            const add = await ask('\n> Found Ollama. Add/update the \'ollama\' summarizer? (Y/n): ');
+            if (add.toLowerCase() !== 'n') {
+                const modelInput = await ask('  - Which Ollama model to use? (press Enter for \'llama3\'): ');
+                const model = modelInput || 'llama3';
+                summarizersToUpdate.push({
+                    name: 'ollama',
+                    tool: 'ollama',
+                    model: model,
+                    prompt: newPrompt,
+                    maxLines: 50,
+                });
+            }
+        }
+        if (availableTools.includes('claude')) {
+            const add = await ask('\n> Found Claude. Add/update the \'claude-opus\' summarizer? (Y/n): ');
+            if (add.toLowerCase() !== 'n') {
+                summarizersToUpdate.push({
+                    name: 'claude-opus',
+                    tool: 'claude',
+                    prompt: newPrompt,
+                    maxLines: 100,
+                });
+            }
+        }
+        if (availableTools.includes('sgpt')) {
+            const add = await ask('\n> Found ShellGPT. Add/update the \'sgpt\' summarizer? (Y/n): ');
+            if (add.toLowerCase() !== 'n') {
+                summarizersToUpdate.push({
+                    name: 'sgpt',
+                    tool: 'custom',
+                    command: ['sgpt', '--chat', 'session-summary', '"{{prompt}}"'],
+                    prompt: newPrompt,
+                    maxLines: 100,
+                });
+            }
+        }
+        if (summarizersToUpdate.length === 0) {
+            console.log('\nNo configurations were added or updated.');
+            return;
+        }
+        // "Update-or-add" logic
+        summarizersToUpdate.forEach(newS => {
+            const existingIndex = config.summarizer.summarizers.findIndex(s => s.name === newS.name);
+            if (existingIndex !== -1) {
+                config.summarizer.summarizers[existingIndex] = newS; // Update
+                console.log(`  - Updated existing summarizer: "${newS.name}"`);
+            }
+            else {
+                config.summarizer.summarizers.push(newS); // Add
+                console.log(`  - Added new summarizer: "${newS.name}"`);
             }
-            process.exit(exitCode);
         });
-    }, 500); // 500ms delay
-});
-process.on('SIGINT', () => {
-    term.kill('SIGINT');
-});
-process.on('resize', () => {
-    term.resize(process.stdout.columns, process.stdout.rows);
-    xterm.resize(process.stdout.columns, process.stdout.rows);
-});
+        // Set default only if it wasn't set before
+        if (!config.summarizer.default && config.summarizer.summarizers.length > 0) {
+            const priority = ['gemini-pro', 'claude-opus', 'ollama', 'sgpt'];
+            for (const name of priority) {
+                if (config.summarizer.summarizers.some(s => s.name === name)) {
+                    config.summarizer.default = name;
+                    console.log(`\n✔ Set "${config.summarizer.default}" as the default summarizer.`);
+                    break;
+                }
+            }
+        }
+        writeConfig(config, isLocal);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function getAiSummary(content, summarizerName) {
+    const config = readConfig();
+    const name = summarizerName || config.summarizer.default;
+    if (!name) {
+        console.warn(`\nWarning: No default summarizer set. Please run 'ai-cli-log --init'.`);
+        return null;
+    }
+    const summarizer = config.summarizer.summarizers.find(s => s.name === name);
+    if (!summarizer) {
+        console.warn(`\nWarning: No summarizer named "${name}" found. Please check your configuration.`);
+        return null;
+    }
+    const { tool, model, prompt, maxLines = 0, command: customCommand } = summarizer;
+    let sampledContent = content;
+    const lines = content.split('\n');
+    if (maxLines > 0 && lines.length > maxLines * 2) {
+        const head = lines.slice(0, maxLines).join('\n');
+        const tail = lines.slice(-maxLines).join('\n');
+        sampledContent = `${head}\n\n[... Session content truncated ...]\n\n${tail}`;
+        console.log(`\n(Session content long, sampling first and last ${maxLines} lines for summary)`);
+    }
+    let command;
+    let inputForStdin;
+    switch (tool) {
+        case 'ollama':
+            command = ['ollama', 'run', model || ''];
+            inputForStdin = `${prompt}\n\n${sampledContent}`;
+            break;
+        case 'gemini':
+            command = ['gemini', '-p', prompt];
+            inputForStdin = sampledContent;
+            break;
+        case 'claude':
+            command = ['claude', '-p', prompt];
+            inputForStdin = sampledContent;
+            break;
+        case 'custom':
+            if (!customCommand) {
+                console.error(`Custom summarizer "${name}" is missing the "command" definition.`);
+                return null;
+            }
+            command = customCommand.map(arg => arg.replace('{{prompt}}', prompt));
+            inputForStdin = sampledContent;
+            break;
+        default:
+            console.error(`Tool "${tool}" is not directly supported yet.`);
+            return null;
+    }
+    command = command.filter(Boolean);
+    const [cmd, ...args] = command;
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        let summary = '', errorOutput = '';
+        proc.stdout.on('data', data => {
+            const output = data.toString();
+            summary += output;
+        });
+        proc.stderr.on('data', data => {
+            const error = data.toString();
+            errorOutput += error;
+        });
+        proc.on('close', code => {
+            if (code !== 0) {
+                console.error(`\nSummarizer command exited with code ${code}. Stderr: ${errorOutput}`);
+                resolve(null);
+            }
+            else {
+                resolve(summary.trim());
+            }
+        });
+        proc.on('error', err => {
+            console.error(`\nFailed to start summarizer command "${cmd}". Is it in your PATH?`, err);
+            resolve(null);
+        });
+        proc.stdin.write(inputForStdin);
+        proc.stdin.end();
+    });
+}
+function runLoggingSession(command, commandArgs, summaryArg) {
+    const logsDir = path.dirname(LOCAL_CONFIG_PATH);
+    if (!fs.existsSync(logsDir))
+        fs.mkdirSync(logsDir, { recursive: true });
+    const xterm = new headless_1.Terminal({
+        rows: process.stdout.rows || 24,
+        cols: process.stdout.columns || 80,
+        scrollback: Infinity,
+        allowProposedApi: true,
+    });
+    const term = pty.spawn(command, commandArgs, {
+        name: 'xterm-color',
+        cols: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24,
+        cwd: process.cwd(),
+        env: process.env,
+    });
+    const onData = (data) => {
+        process.stdout.write(data);
+        xterm.write(data);
+    };
+    term.onData(onData);
+    const onStdin = (data) => term.write(data.toString());
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('data', onStdin);
+    }
+    const onExit = async ({ exitCode }) => {
+        term.kill();
+        if (process.stdin.isTTY) {
+            process.stdin.removeListener('data', onStdin);
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+        setTimeout(async () => {
+            var _a;
+            let renderedOutput = '';
+            for (let i = 0; i < xterm.buffer.active.baseY + xterm.rows; i++) {
+                renderedOutput += ((_a = xterm.buffer.active.getLine(i)) === null || _a === void 0 ? void 0 : _a.translateToString(true)) + '\n';
+            }
+            renderedOutput = renderedOutput.trim();
+            if (renderedOutput.trim().length === 0) {
+                console.log('\nSession had no output, not saving log file.');
+                process.exit(exitCode);
+            }
+            const now = new Date();
+            const pad = (n) => n.toString().padStart(2, '0');
+            const timestamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+            const prefix = command || 'session';
+            let logFileName = `${prefix}-${timestamp}.txt`;
+            if (summaryArg) {
+                const startTime = Date.now();
+                const rawSummaryJson = await getAiSummary(renderedOutput, typeof summaryArg === 'string' ? summaryArg : undefined);
+                const endTime = Date.now();
+                if (rawSummaryJson) {
+                    const duration = (endTime - startTime) / 1000;
+                    const config = readConfig();
+                    const summarizerName = (typeof summaryArg === 'string' ? summaryArg : config.summarizer.default) || 'default';
+                    try {
+                        const summaryData = JSON.parse(rawSummaryJson);
+                        const slug = summaryData.summary;
+                        if (typeof slug !== 'string') {
+                            throw new Error('Invalid JSON structure from summarizer: "summary" key is missing or not a string.');
+                        }
+                        console.log(`\nSummary by ${summarizerName} (took ${duration.toFixed(1)}s): "${slug}"`);
+                        logFileName = `${prefix}-${timestamp}-${slug}.txt`;
+                    }
+                    catch (e) {
+                        console.error(`\nError parsing summary JSON from ${summarizerName}. Using raw output as fallback.`);
+                        console.error(`Raw output: ${rawSummaryJson}`);
+                        const slugify = (text) => text.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+                        const slug = slugify(rawSummaryJson).split('-').slice(0, 10).join('-');
+                        logFileName = `${prefix}-${timestamp}-${slug}.txt`;
+                    }
+                }
+            }
+            const logFilePath = path.join(logsDir, logFileName);
+            fs.writeFile(logFilePath, renderedOutput, (err) => {
+                if (err) {
+                    console.error('\nError writing log file:', err);
+                }
+                else {
+                    console.log(`\nSession logged to ${path.relative(process.cwd(), logFilePath)}`);
+                }
+                process.exit(exitCode);
+            });
+        }, 200);
+    };
+    term.onExit(onExit);
+    process.on('resize', () => {
+        term.resize(process.stdout.columns, process.stdout.rows);
+        xterm.resize(process.stdout.columns, process.stdout.rows);
+    });
+}
+// --- 3. MAIN ENTRY POINT & ARGUMENT PARSER ---
+function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('--version') || args.includes('-v')) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkg = require('../package.json');
+        console.log(pkg.version);
+        return;
+    }
+    if (args.includes('--init')) {
+        const isLocal = args.includes('--local');
+        handleInitCommand(isLocal);
+        return;
+    }
+    const summaryArgRaw = args.find(arg => arg.startsWith('--with-summary') || arg.startsWith('-s'));
+    const otherArgs = args.filter(arg => !arg.startsWith('--with-summary') &&
+        !arg.startsWith('-s') &&
+        arg !== '--init' &&
+        arg !== '--local');
+    const command = otherArgs[0];
+    const commandArgs = otherArgs.slice(1);
+    if (!command) {
+        console.error('Usage: ai-cli-log [-s[=<summarizer>]] <command> [args...]');
+        console.error('       ai-cli-log --init [--local]');
+        process.exit(1);
+    }
+    let summaryArg = false;
+    if (summaryArgRaw) {
+        summaryArg = summaryArgRaw.includes('=') ? summaryArgRaw.split('=')[1] : true;
+    }
+    runLoggingSession(command, commandArgs, summaryArg);
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cli-log",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Seamlessly log your AI-powered coding conversations. This command-line interface (CLI) tool captures your terminal   interactions with AI models like Gemini and Claude, saving entire sessions as clean plain text documents for easy   review and documentation.",
   "main": "dist/index.js",
   "bin": {