@exreve/exk 1.0.7 → 1.0.8

package/bin/exk

@@ -1,49 +1,20 @@
 #!/usr/bin/env node
 // exk CLI - entry point for npm global install
-// Runs the TypeScript CLI via tsx
+// Runs compiled JavaScript directly (no tsx needed)
 
 import { resolve, dirname } from 'path'
-import { spawn } from 'child_process'
-import fs from 'fs'
 import { fileURLToPath } from 'url'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
-const cliDir = __dirname
-const pkgDir = resolve(cliDir, '..')
-const entryPoint = resolve(pkgDir, 'index.ts')
-
-// Find tsx binary
-let tsxBin = resolve(pkgDir, 'node_modules', '.bin', 'tsx')
-if (!fs.existsSync(tsxBin)) {
-  // Walk up to find tsx in parent node_modules (npm global structure)
-  let dir = pkgDir
-  for (let i = 0; i < 10; i++) {
-    const candidate = resolve(dir, 'node_modules', '.bin', 'tsx')
-    if (fs.existsSync(candidate)) {
-      tsxBin = candidate
-      break
-    }
-    const parent = resolve(dir, '..')
-    if (parent === dir) break
-    dir = parent
-  }
-}
+const pkgDir = resolve(__dirname, '..')
+const entryPoint = resolve(pkgDir, 'dist', 'index.js')
 
 const args = process.argv.slice(2)
 
-const child = spawn(tsxBin, [entryPoint, ...args], {
-  stdio: 'inherit',
-  env: { ...process.env },
-  cwd: pkgDir
-})
-
-child.on('exit', (code) => {
-  process.exit(code ?? 0)
-})
-
-child.on('error', (err) => {
+// Import and run the compiled CLI
+import(entryPoint).catch(err => {
   console.error('Failed to start exk:', err.message)
   process.exit(1)
 })

package/dist/agentLogger.js

@@ -0,0 +1,143 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const LOGS_DIR = path.join(os.homedir(), '.talk-to-code', 'agent-logs');
+const ensureLogsDir = () => fs.mkdir(LOGS_DIR, { recursive: true });
+const getLogFilePath = (sessionId) => path.join(LOGS_DIR, `session-${sessionId}.log`);
+const formatTimestamp = () => new Date().toISOString();
+async function writeLog(sessionId, level, message, data) {
+    try {
+        await ensureLogsDir();
+        const logFile = getLogFilePath(sessionId);
+        const dataStr = data ? ` | Data: ${JSON.stringify(data)}` : '';
+        await fs.appendFile(logFile, `[${formatTimestamp()}] [${level}] ${message}${dataStr}\n`, 'utf-8');
+    }
+    catch (error) {
+        console.error(`Failed to write log: ${error}`);
+    }
+}
+/**
+ * Agent session logger
+ */
+export class AgentLogger {
+    sessionId;
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+    }
+    async info(message, data) {
+        await writeLog(this.sessionId, 'INFO', message, data);
+        const dataStr = data ? ` | ${JSON.stringify(data).substring(0, 200)}` : '';
+        console.log(`[Agent] [${this.sessionId}] ${message}${dataStr}`);
+    }
+    async error(message, error) {
+        const errorData = error instanceof Error
+            ? { message: error.message, stack: error.stack, name: error.name }
+            : error;
+        await writeLog(this.sessionId, 'ERROR', message, errorData);
+        console.error(`[Agent] [${this.sessionId}] ✗ ERROR: ${message}`);
+        if (error instanceof Error) {
+            console.error(`  → ${error.message}`);
+            if (error.stack && process.env.DEBUG_AGENT) {
+                console.error(`  Stack: ${error.stack}`);
+            }
+        }
+        else if (error) {
+            console.error(`  → ${JSON.stringify(error).substring(0, 500)}`);
+        }
+    }
+    async warn(message, data) {
+        await writeLog(this.sessionId, 'WARN', message, data);
+        const dataStr = data ? ` | ${JSON.stringify(data).substring(0, 200)}` : '';
+        console.warn(`[Agent] [${this.sessionId}] ⚠ WARN: ${message}${dataStr}`);
+    }
+    async debug(message, data) {
+        await writeLog(this.sessionId, 'DEBUG', message, data);
+        if (process.env.DEBUG_AGENT) {
+            const dataStr = data ? ` | ${JSON.stringify(data).substring(0, 200)}` : '';
+            console.log(`[Agent] [${this.sessionId}] 🔍 DEBUG: ${message}${dataStr}`);
+        }
+    }
+    /**
+     * Log prompt processing start
+     */
+    async logPromptStart(prompt, projectPath) {
+        await this.info('📤 Prompt processing started', {
+            promptLength: prompt.length,
+            promptPreview: prompt.substring(0, 200),
+            projectPath
+        });
+        console.log(`[Agent] [${this.sessionId}] 📤 Processing prompt (${prompt.length} chars)`);
+        console.log(`[Agent] [${this.sessionId}]    Preview: ${prompt.substring(0, 150)}${prompt.length > 150 ? '...' : ''}`);
+    }
+    async logPromptEnd(exitCode, duration, tokenUsage) {
+        const durationSec = (duration / 1000).toFixed(2);
+        const status = exitCode === 0 || exitCode === null ? '✓' : '✗';
+        await this.info('Prompt processing completed', {
+            exitCode,
+            durationMs: duration,
+            durationSeconds: durationSec,
+            tokenUsage
+        });
+        console.log(`[Agent] [${this.sessionId}] ${status} Prompt completed in ${durationSec}s (exit: ${exitCode ?? 'null'})`);
+        if (tokenUsage) {
+            console.log(`[Agent] [${this.sessionId}]    Tokens: ${tokenUsage.inputTokens} in + ${tokenUsage.outputTokens} out = ${tokenUsage.inputTokens + tokenUsage.outputTokens} total`);
+            console.log(`[Agent] [${this.sessionId}]    Cost: $${tokenUsage.costUsd.toFixed(6)}`);
+        }
+    }
+    async logToolCall(toolName, toolData) {
+        await this.debug('Tool called', {
+            toolName,
+            toolData: typeof toolData === 'string' ? toolData.substring(0, 500) : toolData
+        });
+        console.log(`[Agent] [${this.sessionId}] 🔧 Tool: ${toolName}`);
+    }
+    async logToolResult(toolName, result, success) {
+        await this.debug('Tool result', {
+            toolName,
+            success,
+            resultPreview: typeof result === 'string' ? result.substring(0, 500) : JSON.stringify(result).substring(0, 500)
+        });
+        const status = success ? '✓' : '✗';
+        const resultPreview = typeof result === 'string'
+            ? result.substring(0, 100)
+            : JSON.stringify(result).substring(0, 100);
+        const resultLen = typeof result === 'string' ? result.length : JSON.stringify(result).length;
+        console.log(`[Agent] [${this.sessionId}] ${status} Tool result (${toolName}): ${resultPreview}${resultLen > 100 ? '...' : ''}`);
+    }
+    async logAgentResponse(response, metadata) {
+        await this.info('Agent response', {
+            responseLength: response.length,
+            responsePreview: response.substring(0, 500),
+            metadata
+        });
+    }
+    async logSessionCreated(projectPath) {
+        await this.info('Session created', { projectPath });
+        console.log(`[Agent] [${this.sessionId}] 🚀 Session created`);
+        console.log(`[Agent] [${this.sessionId}]    Project: ${projectPath}`);
+    }
+    async logSessionError(error, context) {
+        const errorMessage = error instanceof Error ? error.message : error;
+        await this.error('Session error', {
+            error: errorMessage,
+            stack: error instanceof Error ? error.stack : undefined,
+            context
+        });
+    }
+    async logClaudeSessionId(sessionId) {
+        await this.info('Claude SDK session ID captured', { claudeSessionId: sessionId });
+        console.log(`[Agent] [${this.sessionId}] 🔗 Claude SDK session ID: ${sessionId.substring(0, 20)}...`);
+    }
+    async logModelConfig(model, baseUrl) {
+        await this.info('Model configuration', { model, baseUrl });
+        console.log(`[Agent] [${this.sessionId}] ⚙️  Model: ${model}`);
+        if (baseUrl) {
+            console.log(`[Agent] [${this.sessionId}]    Base URL: ${baseUrl}`);
+        }
+    }
+    async logTokenUsage(usage) {
+        await this.info('Token usage', usage);
+        console.log(`[Agent] [${this.sessionId}] 📊 Token usage: ${usage.inputTokens} in + ${usage.outputTokens} out = ${usage.totalTokens} total`);
+        console.log(`[Agent] [${this.sessionId}]    Cost: $${usage.costUsd.toFixed(6)}`);
+    }
+}