@exreve/exk 1.0.55 → 1.0.56

package/dist/projectAnalyzer.js

@@ -1,330 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import fs from 'fs/promises';
-import path from 'path';
-import { agentSessionManager } from './agentSession.js';
-const CONFIG_FILENAME = '.claude-voice.json';
-/**
- * Analyze project using Claude AI and generate structured JSON configuration
- */
-export async function analyzeProjectWithClaude(projectPath, projectName) {
-    // Create a temporary session ID for analysis
-    const analysisSessionId = `analysis-${uuidv4()}`;
-    // Build the analysis prompt with structured output requirements
-    const analysisPrompt = `Analyze the project structure at ${projectPath} and generate a comprehensive project configuration.
-
-CRITICAL: You must identify ALL applications/services in this project. Each app will get its own TypeScript runner file and entry in the JSON config.
-
-Please examine:
-1. Project files and directory structure (use Read/Glob tools to explore)
-2. Framework and technology stack (React, Express, FastAPI, Django, etc.)
-3. Apps (applications/services) - each app can be at root or in subdirectories
-4. For each app, identify:
-   - App NAME: unique identifier for the app
-   - App TYPE: "static-frontend" (React/Vue/Angular/Svelte/Next.js static builds) or "backend" (Express/Fastify/FastAPI/Django/etc.)
-   - How to BUILD it (buildCommand - REQUIRED for static frontends)
-   - How to START it (startCommand - REQUIRED for all apps)
-   - How to STOP it (stopCommand - optional, defaults to killing process)
-   - How to RESTART it (restartCommand - optional, defaults to stop + start)
-   - Port number (port - REQUIRED for HTTP apps)
-   - Protocol (http/https/ws/etc.)
-   - HTTP endpoints/routes (endpoints array)
-   - Framework name (react/express/fastify/etc.)
-   - Directory location (relative to project root, empty string "" for root app)
-   - Build output directory (buildDir - for static frontends: dist/build/public)
-   - Environment variables (env object)
-   - Health check URL or command
-5. Check package.json scripts, Makefile, docker-compose.yml, Procfile, vite.config.js, next.config.js, etc. for commands
-6. Detect HTTP endpoints by examining route files, controllers, or API definitions
-7. For static frontends, identify the build output directory (usually dist, build, or public)
-8. Look for multiple apps in monorepos or multi-app projects
-
-IMPORTANT OUTPUT REQUIREMENTS:
-- You must output a JSON file named ".talk-to-code.json" in the project root
-- The JSON must contain ALL apps/services found in the project
-- Each app will be wrapped with a TypeScript runner file (generated automatically)
-- Apps must be configured to work with the runner system
-
-Output ONLY valid JSON matching this exact structure (no markdown, no code blocks, no explanations, just pure JSON):
-
-{
-  "version": "1.0.0",
-  "projectName": "${projectName}",
-  "description": "Description of the project",
-  "apps": [
-    {
-      "name": "app-name",
-      "description": "Optional description",
-      "type": "http",
-      "port": 3000,
-      "protocol": "http",
-      "directory": "relative/path/to/app",
-      "framework": "react",
-      "appType": "static-frontend",
-      "buildDir": "dist",
-      "endpoints": ["/", "/api", "/api/v1"],
-      "env": {},
-      "healthCheck": {
-        "url": "http://localhost:3000/health"
-      },
-      "buildCommand": "npm run build",
-      "startCommand": "npm start",
-      "stopCommand": "pkill -f 'node.*start'",
-      "restartCommand": null,
-      "dependencies": []
-    }
-  ],
-  "directories": ["subdirectory1", "subdirectory2"],
-  "metadata": {
-    "analyzedAt": "${new Date().toISOString()}",
-    "analyzedBy": "talk-to-code-agent",
-    "framework": "detected-framework",
-    "language": "javascript",
-    "packageManager": "npm"
-  }
-}
-
-CRITICAL INSTRUCTIONS:
-1. Output ONLY the JSON object, nothing else
-2. No markdown formatting, no code blocks, no explanations
-3. Use Read/Glob tools to examine the project structure thoroughly
-4. Extract actual port numbers, commands, and configurations from files
-5. startCommand is REQUIRED for each app - must be the actual command to start the app
-6. stopCommand and restartCommand are optional (can be null)
-7. appType MUST be "static-frontend" for React/Vue/Angular/Svelte/Next.js static builds, or "backend" for Express/Fastify/FastAPI/Django/etc.
-8. buildDir MUST be specified for static frontends (usually "dist", "build", or "public")
-9. port is REQUIRED for HTTP apps
-10. endpoints should be an array of HTTP routes (e.g., ["/", "/api", "/api/v1"])
-11. directory should be relative path from project root, empty string "" for root app
-12. Be thorough and accurate - identify ALL apps/services in the project
-13. Each app will get a TypeScript runner file ({appName}_runner.ts) generated automatically
-14. The runner will wrap the app to collect logs, stats, and provide unified control
-15. After generating the JSON, write it to ".claude-voice.json" file in the project root using the Write tool`;
-    let config = null;
-    let lastAssistantMessage = '';
-    let errorOccurred = false;
-    let foundJson = false;
-    const assistantMessages = [];
-    try {
-        // Create temporary session handler
-        await agentSessionManager.createSession({
-            sessionId: analysisSessionId,
-            projectPath,
-            onOutput: (output) => {
-                // Capture assistant messages to extract JSON
-                if (output.type === 'assistant') {
-                    const data = typeof output.data === 'string' ? output.data : JSON.stringify(output.data);
-                    assistantMessages.push(data);
-                    lastAssistantMessage = data;
-                }
-                // Check for file writes (Claude might write the JSON file directly)
-                if (output.type === 'tool_result' && output.metadata?.toolName === 'Write') {
-                    const toolResult = output.metadata.toolResult;
-                    if (toolResult && typeof toolResult === 'object' && 'file_path' in toolResult) {
-                        const filePath = toolResult.file_path;
-                        if (filePath && filePath.includes('.talk-to-code.json')) {
-                            // Claude wrote the config file, mark as found
-                            foundJson = true;
-                        }
-                    }
-                }
-                if (output.type === 'result' && output.metadata?.isError) {
-                    errorOccurred = true;
-                }
-            },
-            onError: (error) => {
-                console.error(`Analysis session error: ${error}`);
-                errorOccurred = true;
-            },
-            onComplete: () => {
-                // Session completed
-            }
-        });
-        // Send analysis prompt
-        await agentSessionManager.sendPrompt(analysisSessionId, analysisPrompt, [], {
-            sessionId: analysisSessionId,
-            projectPath,
-            onOutput: (output) => {
-                // Capture assistant messages
-                if (output.type === 'assistant') {
-                    const data = typeof output.data === 'string' ? output.data : JSON.stringify(output.data);
-                    assistantMessages.push(data);
-                    lastAssistantMessage = data;
-                }
-                // Also check for file writes (Claude might write the JSON file directly)
-                if (output.type === 'tool_result' && output.metadata?.toolName === 'Write') {
-                    // Claude wrote a file, check if it's the config file
-                    const toolResult = output.metadata.toolResult;
-                    if (toolResult && typeof toolResult === 'object' && 'file_path' in toolResult) {
-                        const filePath = toolResult.file_path;
-                        if (filePath && filePath.includes('.talk-to-code.json')) {
-                            // Claude wrote the config file, try to read it
-                            setTimeout(async () => {
-                                try {
-                                    const configPath = path.join(projectPath, '.talk-to-code.json');
-                                    const content = await fs.readFile(configPath, 'utf-8');
-                                    const parsed = JSON.parse(content);
-                                    if (parsed && parsed.apps) {
-                                        config = parsed;
-                                        foundJson = true;
-                                    }
-                                }
-                                catch (error) {
-                                    // Ignore read errors
-                                }
-                            }, 1000);
-                        }
-                    }
-                }
-            },
-            onError: (error) => {
-                console.error(`Analysis error: ${error}`);
-                errorOccurred = true;
-            },
-            onComplete: () => {
-                // Analysis complete
-            }
-        });
-        // Wait for Claude to process (give it time to read files and generate response)
-        // Use exponential backoff: start at 500ms, double each time, cap at 5s, timeout at 90s
-        const configFilePath = path.join(projectPath, CONFIG_FILENAME);
-        const POLL_TIMEOUT_MS = 90_000;
-        const POLL_START_MS = 500;
-        const POLL_MAX_MS = 5_000;
-        let elapsed = 0;
-        let interval = POLL_START_MS;
-        while (elapsed < POLL_TIMEOUT_MS) {
-            await new Promise(resolve => setTimeout(resolve, interval));
-            elapsed += interval;
-            interval = Math.min(interval * 2, POLL_MAX_MS);
-            // Check if Claude wrote the config file directly
-            try {
-                await fs.access(configFilePath);
-                const fileContent = await fs.readFile(configFilePath, 'utf-8');
-                const parsed = JSON.parse(fileContent);
-                if (parsed && parsed.apps) {
-                    config = parsed;
-                    foundJson = true;
-                    break;
-                }
-            }
-            catch {
-                // File doesn't exist yet or invalid JSON, continue waiting
-            }
-            // Check if we have a complete JSON response in messages
-            if (lastAssistantMessage && (lastAssistantMessage.includes('"version"') || lastAssistantMessage.includes('"apps"') || lastAssistantMessage.includes('"services"'))) {
-                foundJson = true;
-                break;
-            }
-            // Check if session completed (result message received)
-            if (errorOccurred) {
-                break;
-            }
-        }
-        // If config was read from file, use it instead of parsing messages
-        if (!config || !foundJson) {
-            // Try to extract JSON from the assistant messages (check all messages, latest first)
-            for (let i = assistantMessages.length - 1; i >= 0; i--) {
-                let jsonStr = assistantMessages[i].trim();
-                // Remove markdown code blocks if present
-                jsonStr = jsonStr.replace(/^```json\s*/i, '').replace(/^```\s*/, '').replace(/\s*```$/, '');
-                jsonStr = jsonStr.trim();
-                // Try to extract JSON object if wrapped in text
-                const jsonMatch = jsonStr.match(/\{[\s\S]*\}/);
-                if (jsonMatch) {
-                    jsonStr = jsonMatch[0];
-                }
-                try {
-                    const parsedConfig = JSON.parse(jsonStr);
-                    config = parsedConfig;
-                    foundJson = true;
-                    break;
-                }
-                catch (parseError) {
-                    // Try next message
-                    continue;
-                }
-            }
-        }
-        // Validate and ensure required fields if config was loaded
-        if (config && foundJson) {
-            // Validate and ensure required fields
-            if (!config.version)
-                config.version = '1.0.0';
-            if (!config.projectName)
-                config.projectName = projectName;
-            if (!config.apps)
-                config.apps = [];
-            if (!config.directories)
-                config.directories = [];
-            // Migrate old "services" to "apps" if present
-            if (config.services && !config.apps) {
-                config.apps = config.services;
-            }
-            // Ensure each app has a startCommand
-            config.apps = config.apps.map(app => ({
-                ...app,
-                startCommand: app.startCommand || 'echo "No start command configured"',
-            }));
-            if (!config.metadata) {
-                config.metadata = {
-                    analyzedAt: new Date().toISOString(),
-                    analyzedBy: 'talk-to-code-agent'
-                };
-            }
-            else {
-                config.metadata.analyzedAt = new Date().toISOString();
-                config.metadata.analyzedBy = 'talk-to-code-agent';
-            }
-        }
-        // Clean up session
-        try {
-            await agentSessionManager.deleteSession(analysisSessionId);
-        }
-        catch (cleanupError) {
-            console.warn(`Failed to cleanup analysis session:`, cleanupError);
-        }
-    }
-    catch (error) {
-        console.error(`Error during Claude analysis:`, error.message);
-        errorOccurred = true;
-        // Try to cleanup session
-        try {
-            await agentSessionManager.deleteSession(analysisSessionId);
-        }
-        catch { }
-    }
-    // If analysis failed or no config extracted, throw error (caller can handle fallback)
-    if (!config || errorOccurred) {
-        throw new Error(`Claude analysis failed or incomplete. Last message: ${lastAssistantMessage.substring(0, 200)}`);
-    }
-    return config;
-}
-/**
- * Read project configuration from file
- */
-export async function getProjectConfig(projectPath) {
-    try {
-        const configPath = path.join(projectPath, CONFIG_FILENAME);
-        const content = await fs.readFile(configPath, 'utf-8');
-        const config = JSON.parse(content);
-        // Migrate old "services" to "apps" if present
-        if (config.services && !config.apps) {
-            config.apps = config.services;
-        }
-        return config;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            return null; // Config file doesn't exist yet
-        }
-        throw error;
-    }
-}
-/**
- * Save project configuration to file
- */
-export async function saveProjectConfig(projectPath, config) {
-    const configPath = path.join(projectPath, CONFIG_FILENAME);
-    const content = JSON.stringify(config, null, 2);
-    await fs.writeFile(configPath, content, 'utf-8');
-}

package/dist/projectManager.js

@@ -1,69 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-const toAbsolutePath = (p) => path.isAbsolute(p) ? p : path.resolve(p);
-export async function createProject(request) {
-    try {
-        const { path: projectPath, sourcePath } = request;
-        const absolutePath = toAbsolutePath(projectPath);
-        // Check if source path exists (if linking)
-        if (sourcePath) {
-            const absoluteSourcePath = toAbsolutePath(sourcePath);
-            try {
-                const sourceStat = await fs.stat(absoluteSourcePath);
-                if (!sourceStat.isDirectory()) {
-                    return { success: false, error: 'Source path is not a directory' };
-                }
-            }
-            catch {
-                return { success: false, error: 'Source path does not exist' };
-            }
-        }
-        // Check if project directory already exists
-        try {
-            const stat = await fs.stat(absolutePath);
-            if (!stat.isDirectory()) {
-                return { success: false, error: 'Path exists but is not a directory' };
-            }
-        }
-        catch {
-            // Directory doesn't exist, create it
-            try {
-                await fs.mkdir(absolutePath, { recursive: true });
-            }
-            catch (error) {
-                return { success: false, error: `Failed to create directory: ${error.message}` };
-            }
-        }
-        // If linking to source, create symlink or copy (for now, just validate)
-        // In a real implementation, you might want to create a symlink or copy files
-        if (sourcePath) {
-            // For now, we just validate that both paths exist
-            // The actual linking can be done by the application logic
-        }
-        return { success: true, actualPath: absolutePath };
-    }
-    catch (error) {
-        return { success: false, error: error.message };
-    }
-}
-export async function deleteProject(projectPath) {
-    try {
-        const absolutePath = toAbsolutePath(projectPath);
-        try {
-            const stat = await fs.stat(absolutePath);
-            if (!stat.isDirectory()) {
-                return { success: false, error: 'Path is not a directory' };
-            }
-        }
-        catch {
-            // Directory doesn't exist, consider it deleted
-            return { success: true };
-        }
-        // Don't delete the directory on device - just succeed
-        // The directory will remain on the filesystem
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: error.message };
-    }
-}

package/dist/runnerGenerator.js

@@ -1,210 +0,0 @@
-/**
- * Generate TypeScript runner code for an app
- */
-export function generateRunnerCode(app, projectPath) {
-    const appType = app.appType || (app.framework?.toLowerCase().includes('react') ||
-        app.framework?.toLowerCase().includes('vue') ||
-        app.framework?.toLowerCase().includes('angular') ||
-        app.framework?.toLowerCase().includes('svelte') ? 'static-frontend' : 'backend');
-    if (appType === 'static-frontend') {
-        return generateStaticFrontendRunner(app, projectPath);
-    }
-    else {
-        return generateBackendRunner(app, projectPath);
-    }
-}
-function generateStaticFrontendRunner(app, _projectPath) {
-    const appName = app.name.replace(/[^a-zA-Z0-9_-]/g, '_'); // Sanitize app name for filename
-    const port = app.port || 3000;
-    const buildDir = app.buildDir || 'dist';
-    const appDir = app.directory || '';
-    return `import Fastify from 'fastify'
-import fastifyStatic from '@fastify/static'
-import path from 'path'
-import fs from 'fs/promises'
-import { fileURLToPath } from 'url'
-import { dirname } from 'path'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const PORT = ${port}
-const BUILD_DIR = path.join(__dirname, ${appDir ? `'${appDir}', ` : ''}'${buildDir}')
-
-async function start() {
-  // Check if build directory exists
-  try {
-    await fs.access(BUILD_DIR)
-  } catch {
-    console.error(\`✗ Build directory not found: \${BUILD_DIR}\`)
-    console.error('  Please build the project first using: ' + (process.env.BUILD_COMMAND || 'npm run build'))
-    process.exit(1)
-  }
-
-  const fastify = Fastify({
-    logger: {
-      level: 'info',
-      transport: {
-        target: 'pino-pretty',
-        options: {
-          translateTime: 'HH:MM:ss Z',
-          ignore: 'pid,hostname',
-        },
-      },
-    },
-  })
-
-  // Register static file serving
-  await fastify.register(fastifyStatic, {
-    root: BUILD_DIR,
-    prefix: '/',
-  })
-
-  // Request logging
-  fastify.addHook('onRequest', async (request, reply) => {
-    const logLine = \`[\${new Date().toISOString()}] \${request.method} \${request.url} - \${reply.statusCode}\\n\`
-    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
-  })
-
-  // Error handling
-  fastify.setErrorHandler(async (error, request, reply) => {
-    const logLine = \`[\${new Date().toISOString()}] ERROR: \${error.message} - \${request.method} \${request.url}\\n\`
-    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
-    reply.status(500).send({ error: 'Internal Server Error' })
-  })
-
-  try {
-    await fastify.listen({ port: PORT, host: '0.0.0.0' })
-    console.log(\`✓ Static server started on port \${PORT}\`)
-    console.log(\`  Serving from: \${BUILD_DIR}\`)
-  } catch (error: any) {
-    console.error(\`✗ Failed to start server:\`, error.message)
-    process.exit(1)
-  }
-}
-
-// Handle graceful shutdown
-process.on('SIGTERM', async () => {
-  console.log('Shutting down...')
-  await fastify.close()
-  process.exit(0)
-})
-
-process.on('SIGINT', async () => {
-  console.log('Shutting down...')
-  await fastify.close()
-  process.exit(0)
-})
-
-start()
-`;
-}
-function generateBackendRunner(app, _projectPath) {
-    const appName = app.name.replace(/[^a-zA-Z0-9_-]/g, '_'); // Sanitize app name for filename
-    const appDir = app.directory || '';
-    const startCommand = app.startCommand;
-    const envVars = app.env || {};
-    const envString = Object.entries(envVars)
-        .map(([key, value]) => `    ${key}: '${value}',`)
-        .join('\n');
-    return `import { spawn } from 'child_process'
-import fs from 'fs/promises'
-import path from 'path'
-import { fileURLToPath } from 'url'
-import { dirname } from 'path'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const APP_DIR = path.join(__dirname, ${appDir ? `'${appDir}'` : 'undefined'})
-const START_COMMAND = '${startCommand}'
-
-const env = {
-  ...process.env,
-${envString}
-  NODE_ENV: process.env.NODE_ENV || 'development',
-}
-
-let childProcess: ReturnType<typeof spawn> | null = null
-
-async function start() {
-  const workingDir = APP_DIR || process.cwd()
-  
-  console.log(\`Starting backend app: ${app.name}\`)
-  console.log(\`  Directory: \${workingDir}\`)
-  console.log(\`  Command: \${START_COMMAND}\`)
-
-  const isWin = process.platform === 'win32'
-  const shell = isWin ? (process.env.COMSPEC || 'cmd.exe') : 'sh'
-  const args = isWin ? ['/c', START_COMMAND] : ['-c', START_COMMAND]
-  childProcess = spawn(shell, args, {
-    cwd: workingDir,
-    env,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-
-  if (!childProcess.pid) {
-    console.error('✗ Failed to spawn process')
-    process.exit(1)
-  }
-
-  console.log(\`✓ Backend started with PID: \${childProcess.pid}\`)
-
-  // Capture stdout
-  childProcess.stdout?.on('data', async (data: Buffer) => {
-    const output = data.toString()
-    const logLine = \`[\${new Date().toISOString()}] [STDOUT] \${output}\`
-    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
-    process.stdout.write(output)
-  })
-
-  // Capture stderr
-  childProcess.stderr?.on('data', async (data: Buffer) => {
-    const output = data.toString()
-    const logLine = \`[\${new Date().toISOString()}] [STDERR] \${output}\`
-    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
-    process.stderr.write(output)
-  })
-
-  // Handle process exit
-  childProcess.on('exit', async (code) => {
-    const logLine = \`[\${new Date().toISOString()}] Process exited with code \${code}\\n\`
-    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
-    console.log(\`Process exited with code \${code}\`)
-    childProcess = null
-  })
-
-  // Handle process errors
-  childProcess.on('error', async (error) => {
-    const logLine = \`[\${new Date().toISOString()}] Process error: \${error.message}\\n\`
-    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
-    console.error(\`Process error: \${error.message}\`)
-  })
-}
-
-// Handle graceful shutdown
-process.on('SIGTERM', async () => {
-  console.log('Shutting down...')
-  if (childProcess) {
-    childProcess.kill('SIGTERM')
-    await new Promise(resolve => setTimeout(resolve, 2000))
-    if (childProcess) {
-      childProcess.kill('SIGKILL')
-    }
-  }
-  process.exit(0)
-})
-
-process.on('SIGINT', async () => {
-  console.log('Shutting down...')
-  if (childProcess) {
-    childProcess.kill('SIGTERM')
-    await new Promise(resolve => setTimeout(resolve, 2000))
-    if (childProcess) {
-      childProcess.kill('SIGKILL')
-    }
-  }
-  process.exit(0)
-})
-
-start()
-`;
-}