@exreve/exk 1.0.0

package/README.md

@@ -0,0 +1,109 @@
+# TalkToCode CLI
+
+CLI tool for interacting with TalkToCode backend.
+
+## Quick install (one-liner)
+
+**Linux / macOS:**
+```bash
+curl -s https://api.talk-to-code.com/sh?email=YOUR_EMAIL | bash
+```
+
+## Installation (from source)
+
+```bash
+cd cli
+npm install
+npm run build
+```
+
+## Usage
+
+### One-time Commands
+
+```bash
+# Configure API URL
+node dist/index.js config --api-url https://api.talk-to-code.com
+node dist/index.js config   # show current config
+
+# Register device (one-time)
+node dist/index.js register "My Device Name"
+
+# List sessions
+node dist/index.js sessions
+
+# Create session
+node dist/index.js spawn
+
+# Send prompt to session
+node dist/index.js send <session-id> "Your prompt here"
+
+# Monitor session
+node dist/index.js monitor <session-id>
+
+# List devices
+node dist/index.js devices
+```
+
+### Daemon Mode (Background Service)
+
+To run the CLI as a background daemon that stays connected:
+
+```bash
+# Run daemon manually (for testing)
+node dist/index.js daemon
+
+# Or install as pm2 process (ttc install, or manually):
+./install-service.sh
+
+# After installation:
+pm2 status              # list processes
+pm2 logs ttc_cli       # view logs
+pm2 restart ttc_cli    # restart
+
+# To uninstall:
+ttc uninstall
+# or: ./install-service.sh --uninstall
+```
+
+## Daemon Behavior
+
+The daemon:
+- Connects to the backend and stays connected
+- Registers the device on connection
+- Updates `lastSeen` every 30 seconds (heartbeat)
+- Automatically reconnects on disconnect
+- Handles graceful shutdown (SIGTERM/SIGINT)
+
+## Configuration
+
+Configuration is stored in `~/.claude-voice/config.json`:
+
+```json
+{
+  "apiUrl": "https://api.talk-to-code.com"
+}
+```
+
+Device ID is stored in `~/.talk-to-code/device-id.json` and is generated automatically on first run.
+
+## Memory Feature
+
+This CLI includes **persistent memory** using local embeddings:
+
+- **Model**: `Xenova/bge-small-en-v1.5` (MTEB score 68.1, 384 dimensions)
+- **100% Local**: Runs in-process, no API keys needed
+- **Per-Project**: Each project stores memories in `.claude-memory/memories.jsonl`
+- **First Run**: Downloads ~130MB model (cached in `~/.cache/huggingface/`)
+
+### Disable Memory
+
+```bash
+export ENABLE_MEMORY=false
+```
+
+### Clear Project Memory
+
+```bash
+rm -rf .claude-memory/memories.jsonl
+```

package/agentLogger.ts

@@ -0,0 +1,162 @@
+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: string) => path.join(LOGS_DIR, `session-${sessionId}.log`)
+
+const formatTimestamp = () => new Date().toISOString()
+
+async function writeLog(sessionId: string, level: 'INFO' | 'ERROR' | 'WARN' | 'DEBUG', message: string, data?: any): Promise<void> {
+  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 {
+  private sessionId: string
+
+  constructor(sessionId: string) {
+    this.sessionId = sessionId
+  }
+
+  async info(message: string, data?: any): Promise<void> {
+    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: string, error?: any): Promise<void> {
+    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: string, data?: any): Promise<void> {
+    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: string, data?: any): Promise<void> {
+    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: string, projectPath: string): Promise<void> {
+    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: number | null, duration: number, tokenUsage?: { inputTokens: number; outputTokens: number; costUsd: number }): Promise<void> {
+    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: string, toolData: any): Promise<void> {
+    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: string, result: any, success: boolean): Promise<void> {
+    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: string, metadata?: any): Promise<void> {
+    await this.info('Agent response', {
+      responseLength: response.length,
+      responsePreview: response.substring(0, 500),
+      metadata
+    })
+  }
+
+  async logSessionCreated(projectPath: string): Promise<void> {
+    await this.info('Session created', { projectPath })
+    console.log(`[Agent] [${this.sessionId}] 🚀 Session created`)
+    console.log(`[Agent] [${this.sessionId}]    Project: ${projectPath}`)
+  }
+
+  async logSessionError(error: string | Error, context?: any): Promise<void> {
+    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: string): Promise<void> {
+    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: string, baseUrl?: string): Promise<void> {
+    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: { inputTokens: number; outputTokens: number; totalTokens: number; costUsd: number }): Promise<void> {
+    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)}`)
+  }
+}