cyrus-ai 0.1.35-alpha.2 → 0.1.37

package/dist/app.js

@@ -1,23 +1,23 @@
 #!/usr/bin/env node
-import { EdgeWorker, SharedApplicationServer } from 'cyrus-edge-worker';
-import dotenv from 'dotenv';
-import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync } from 'fs';
-import { resolve, dirname, basename } from 'path';
-import open from 'open';
-import readline from 'readline';
-import http from 'http';
-import { homedir } from 'os';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import http from "node:http";
+import { homedir } from "node:os";
+import { basename, dirname, resolve } from "node:path";
+import readline from "node:readline";
+import { EdgeWorker, SharedApplicationServer, } from "cyrus-edge-worker";
+import dotenv from "dotenv";
+import open from "open";
 // Parse command line arguments
 const args = process.argv.slice(2);
-const envFileArg = args.find(arg => arg.startsWith('--env-file='));
+const envFileArg = args.find((arg) => arg.startsWith("--env-file="));
 // Note: __dirname removed since version is now hardcoded
 // Handle --version argument
-if (args.includes('--version')) {
-    console.log('0.1.28');
+if (args.includes("--version")) {
+    console.log("0.1.37");
     process.exit(0);
 }
 // Handle --help argument
-if (args.includes('--help') || args.includes('-h')) {
+if (args.includes("--help") || args.includes("-h")) {
     console.log(`
 cyrus - AI-powered Linear issue automation using Claude
 
@@ -42,7 +42,7 @@ Examples:
 }
 // Load environment variables only if --env-file is specified
 if (envFileArg) {
-    const envFile = envFileArg.split('=')[1];
+    const envFile = envFileArg.split("=")[1];
     if (envFile) {
         dotenv.config({ path: envFile });
     }
@@ -57,13 +57,13 @@ class EdgeApp {
      * Get the edge configuration file path
      */
     getEdgeConfigPath() {
-        return resolve(homedir(), '.cyrus', 'config.json');
+        return resolve(homedir(), ".cyrus", "config.json");
     }
     /**
      * Get the legacy edge configuration file path (for migration)
      */
     getLegacyEdgeConfigPath() {
-        return resolve(process.cwd(), '.edge-config.json');
+        return resolve(process.cwd(), ".edge-config.json");
     }
     /**
      * Migrate configuration from legacy location if needed
@@ -106,15 +106,15 @@ class EdgeApp {
         let config = { repositories: [] };
         if (existsSync(edgeConfigPath)) {
             try {
-                config = JSON.parse(readFileSync(edgeConfigPath, 'utf-8'));
+                config = JSON.parse(readFileSync(edgeConfigPath, "utf-8"));
             }
             catch (e) {
-                console.error('Failed to load edge config:', e.message);
+                console.error("Failed to load edge config:", e.message);
             }
         }
         // Strip promptTemplatePath from all repositories to ensure built-in template is used
         if (config.repositories) {
-            config.repositories = config.repositories.map(repo => {
+            config.repositories = config.repositories.map((repo) => {
                 const { promptTemplatePath, ...repoWithoutTemplate } = repo;
                 if (promptTemplatePath) {
                     console.log(`Ignoring custom prompt template for repository: ${repo.name} (using built-in template)`);
@@ -142,66 +142,81 @@ class EdgeApp {
     async setupRepositoryWizard(linearCredentials) {
         const rl = readline.createInterface({
             input: process.stdin,
-            output: process.stdout
+            output: process.stdout,
         });
         const question = (prompt) => new Promise((resolve) => {
             rl.question(prompt, resolve);
         });
-        console.log('\n📁 Repository Setup');
-        console.log('─'.repeat(50));
+        console.log("\n📁 Repository Setup");
+        console.log("─".repeat(50));
         try {
             // Ask for repository details
-            const repositoryPath = await question(`Repository path (default: ${process.cwd()}): `) || process.cwd();
-            const repositoryName = await question(`Repository name (default: ${basename(repositoryPath)}): `) || basename(repositoryPath);
-            const baseBranch = await question('Base branch (default: main): ') || 'main';
+            const repositoryPath = (await question(`Repository path (default: ${process.cwd()}): `)) ||
+                process.cwd();
+            const repositoryName = (await question(`Repository name (default: ${basename(repositoryPath)}): `)) || basename(repositoryPath);
+            const baseBranch = (await question("Base branch (default: main): ")) || "main";
             // Create a path-safe version of the repository name for namespacing
-            const repoNameSafe = repositoryName.replace(/[^a-zA-Z0-9-_]/g, '-').toLowerCase();
-            const defaultWorkspaceDir = resolve(homedir(), '.cyrus', 'workspaces', repoNameSafe);
-            const workspaceBaseDir = await question(`Workspace directory (default: ${defaultWorkspaceDir}): `) || defaultWorkspaceDir;
+            const repoNameSafe = repositoryName
+                .replace(/[^a-zA-Z0-9-_]/g, "-")
+                .toLowerCase();
+            const defaultWorkspaceDir = resolve(homedir(), ".cyrus", "workspaces", repoNameSafe);
+            const workspaceBaseDir = (await question(`Workspace directory (default: ${defaultWorkspaceDir}): `)) || defaultWorkspaceDir;
             // Note: Prompt template is now hardcoded - no longer configurable
             // Ask for MCP configuration
-            console.log('\n🔧 MCP (Model Context Protocol) Configuration');
-            console.log('MCP allows Claude to access external tools and data sources.');
-            console.log('Examples: filesystem access, database connections, API integrations');
-            console.log('See: https://docs.anthropic.com/en/docs/claude-code/mcp');
-            console.log('');
+            console.log("\n🔧 MCP (Model Context Protocol) Configuration");
+            console.log("MCP allows Claude to access external tools and data sources.");
+            console.log("Examples: filesystem access, database connections, API integrations");
+            console.log("See: https://docs.anthropic.com/en/docs/claude-code/mcp");
+            console.log("");
             const mcpConfigInput = await question('MCP config file path (optional, format: {"mcpServers": {...}}, e.g., ./mcp-config.json): ');
             const mcpConfigPath = mcpConfigInput.trim() || undefined;
             // Ask for allowed tools configuration
-            console.log('\n🔧 Tool Configuration');
-            console.log('Available tools: Read(**),Edit(**),Bash,Task,WebFetch,WebSearch,TodoRead,TodoWrite,NotebookRead,NotebookEdit,Batch');
-            console.log('');
-            console.log('⚠️  SECURITY NOTE: Bash tool requires special configuration for safety:');
+            console.log("\n🔧 Tool Configuration");
+            console.log("Available tools: Read(**),Edit(**),Bash,Task,WebFetch,WebSearch,TodoRead,TodoWrite,NotebookRead,NotebookEdit,Batch");
+            console.log("");
+            console.log("⚠️  SECURITY NOTE: Bash tool requires special configuration for safety:");
             console.log('   • Use "Bash" for full access (not recommended in production)');
             console.log('   • Use "Bash(npm:*)" to restrict to npm commands only');
             console.log('   • Use "Bash(git:*)" to restrict to git commands only');
-            console.log('   • See: https://docs.anthropic.com/en/docs/claude-code/settings#permissions');
-            console.log('');
-            console.log('Default: All tools except Bash (leave blank for all non-Bash tools)');
-            const allowedToolsInput = await question('Allowed tools (comma-separated, default: all except Bash): ');
-            const allowedTools = allowedToolsInput ? allowedToolsInput.split(',').map(t => t.trim()) : undefined;
+            console.log("   • See: https://docs.anthropic.com/en/docs/claude-code/settings#permissions");
+            console.log("");
+            console.log("Default: All tools except Bash (leave blank for all non-Bash tools)");
+            const allowedToolsInput = await question("Allowed tools (comma-separated, default: all except Bash): ");
+            const allowedTools = allowedToolsInput
+                ? allowedToolsInput.split(",").map((t) => t.trim())
+                : undefined;
             // Ask for team keys configuration
-            console.log('\n🏷️ Team-Based Routing (Optional)');
-            console.log('Configure specific Linear team keys to route issues to this repository.');
-            console.log('Example: CEE,FRONT,BACK for teams with those prefixes');
-            console.log('Leave blank to receive all issues from the workspace.');
-            const teamKeysInput = await question('Team keys (comma-separated, optional): ');
-            const teamKeys = teamKeysInput ? teamKeysInput.split(',').map(t => t.trim().toUpperCase()) : undefined;
+            console.log("\n🏷️ Team-Based Routing (Optional)");
+            console.log("Configure specific Linear team keys to route issues to this repository.");
+            console.log("Example: CEE,FRONT,BACK for teams with those prefixes");
+            console.log("Leave blank to receive all issues from the workspace.");
+            const teamKeysInput = await question("Team keys (comma-separated, optional): ");
+            const teamKeys = teamKeysInput
+                ? teamKeysInput.split(",").map((t) => t.trim().toUpperCase())
+                : undefined;
             // Ask for label-based system prompt configuration
-            console.log('\n🎯 Label-Based System Prompts (Optional)');
-            console.log('Cyrus can use different strategies based on Linear issue labels.');
-            console.log('Configure which labels trigger each specialized mode:');
-            console.log('• Debugger mode: Focuses on systematic problem investigation');
-            console.log('• Builder mode: Emphasizes feature implementation and code quality');
-            console.log('• Scoper mode: Helps analyze requirements and create technical plans');
+            console.log("\n🎯 Label-Based System Prompts (Optional)");
+            console.log("Cyrus can use different strategies based on Linear issue labels.");
+            console.log("Configure which labels trigger each specialized mode:");
+            console.log("• Debugger mode: Focuses on systematic problem investigation");
+            console.log("• Builder mode: Emphasizes feature implementation and code quality");
+            console.log("• Scoper mode: Helps analyze requirements and create technical plans");
             const debuggerLabelsInput = await question('Labels for debugger mode (comma-separated, e.g., "Bug"): ');
             const builderLabelsInput = await question('Labels for builder mode (comma-separated, e.g., "Feature,Improvement"): ');
             const scoperLabelsInput = await question('Labels for scoper mode (comma-separated, e.g., "PRD"): ');
-            const labelPrompts = (debuggerLabelsInput || builderLabelsInput || scoperLabelsInput) ? {
-                ...(debuggerLabelsInput && { debugger: debuggerLabelsInput.split(',').map(l => l.trim()) }),
-                ...(builderLabelsInput && { builder: builderLabelsInput.split(',').map(l => l.trim()) }),
-                ...(scoperLabelsInput && { scoper: scoperLabelsInput.split(',').map(l => l.trim()) })
-            } : undefined;
+            const labelPrompts = debuggerLabelsInput || builderLabelsInput || scoperLabelsInput
+                ? {
+                    ...(debuggerLabelsInput && {
+                        debugger: debuggerLabelsInput.split(",").map((l) => l.trim()),
+                    }),
+                    ...(builderLabelsInput && {
+                        builder: builderLabelsInput.split(",").map((l) => l.trim()),
+                    }),
+                    ...(scoperLabelsInput && {
+                        scoper: scoperLabelsInput.split(",").map((l) => l.trim()),
+                    }),
+                }
+                : undefined;
             rl.close();
             // Create repository configuration
             const repository = {
@@ -216,7 +231,7 @@ class EdgeApp {
                 ...(allowedTools && { allowedTools }),
                 ...(mcpConfigPath && { mcpConfigPath: resolve(mcpConfigPath) }),
                 ...(teamKeys && { teamKeys }),
-                ...(labelPrompts && { labelPrompts })
+                ...(labelPrompts && { labelPrompts }),
             };
             return repository;
         }
@@ -246,7 +261,9 @@ class EdgeApp {
         }
         else {
             // Create temporary SharedApplicationServer for OAuth flow during initial setup
-            const serverPort = process.env.CYRUS_SERVER_PORT ? parseInt(process.env.CYRUS_SERVER_PORT, 10) : 3456;
+            const serverPort = process.env.CYRUS_SERVER_PORT
+                ? parseInt(process.env.CYRUS_SERVER_PORT, 10)
+                : 3456;
             const tempServer = new SharedApplicationServer(serverPort);
             try {
                 // Start the server
@@ -267,7 +284,7 @@ class EdgeApp {
                 return {
                     linearToken: result.linearToken,
                     linearWorkspaceId: result.linearWorkspaceId,
-                    linearWorkspaceName: result.linearWorkspaceName
+                    linearWorkspaceName: result.linearWorkspaceName,
                 };
             }
             finally {
@@ -300,7 +317,7 @@ class EdgeApp {
         console.log(``);
         const rl = readline.createInterface({
             input: process.stdin,
-            output: process.stdout
+            output: process.stdout,
         });
         return new Promise((resolve) => {
             rl.question(`Enter your ngrok auth token (or press Enter to skip): `, async (token) => {
@@ -327,7 +344,7 @@ class EdgeApp {
     /**
      * Start the EdgeWorker with given configuration
      */
-    async startEdgeWorker({ proxyUrl, repositories }) {
+    async startEdgeWorker({ proxyUrl, repositories, }) {
         // Get ngrok auth token (prompt if needed and not external host)
         let ngrokAuthToken;
         if (process.env.CYRUS_HOST_EXTERNAL !== "true") {
@@ -338,13 +355,15 @@ class EdgeApp {
         const config = {
             proxyUrl,
             repositories,
-            defaultAllowedTools: process.env.ALLOWED_TOOLS?.split(",").map(t => t.trim()) || [],
+            defaultAllowedTools: process.env.ALLOWED_TOOLS?.split(",").map((t) => t.trim()) || [],
             webhookBaseUrl: process.env.CYRUS_BASE_URL,
-            serverPort: process.env.CYRUS_SERVER_PORT ? parseInt(process.env.CYRUS_SERVER_PORT, 10) : 3456,
+            serverPort: process.env.CYRUS_SERVER_PORT
+                ? parseInt(process.env.CYRUS_SERVER_PORT, 10)
+                : 3456,
             serverHost: process.env.CYRUS_HOST_EXTERNAL === "true" ? "0.0.0.0" : "localhost",
             ngrokAuthToken,
             features: {
-                enableContinuation: true
+                enableContinuation: true,
             },
             handlers: {
                 createWorkspace: async (issue, repository) => {
@@ -354,7 +373,7 @@ class EdgeApp {
                     const linearCredentials = {
                         linearToken: token,
                         linearWorkspaceId: workspaceId,
-                        linearWorkspaceName: workspaceName
+                        linearWorkspaceName: workspaceName,
                     };
                     // Handle OAuth completion for repository setup
                     if (this.edgeWorker) {
@@ -363,33 +382,36 @@ class EdgeApp {
                         try {
                             const newRepo = await this.setupRepositoryWizard(linearCredentials);
                             // Add to existing repositories
-                            let edgeConfig = this.loadEdgeConfig();
+                            const edgeConfig = this.loadEdgeConfig();
                             console.log(`📊 Current config has ${edgeConfig.repositories?.length || 0} repositories`);
-                            edgeConfig.repositories = [...(edgeConfig.repositories || []), newRepo];
+                            edgeConfig.repositories = [
+                                ...(edgeConfig.repositories || []),
+                                newRepo,
+                            ];
                             console.log(`📊 Adding repository "${newRepo.name}", new total: ${edgeConfig.repositories.length}`);
                             this.saveEdgeConfig(edgeConfig);
-                            console.log('\n✅ Repository configured successfully!');
-                            console.log('📝 ~/.cyrus/config.json file has been updated with your new repository configuration.');
-                            console.log('💡 You can edit this file and restart Cyrus at any time to modify settings.');
+                            console.log("\n✅ Repository configured successfully!");
+                            console.log("📝 ~/.cyrus/config.json file has been updated with your new repository configuration.");
+                            console.log("💡 You can edit this file and restart Cyrus at any time to modify settings.");
                             // Restart edge worker with new config
                             await this.edgeWorker.stop();
                             this.edgeWorker = null;
                             // Give a small delay to ensure file is written
-                            await new Promise(resolve => setTimeout(resolve, 100));
+                            await new Promise((resolve) => setTimeout(resolve, 100));
                             // Reload configuration and restart worker without going through setup
                             const updatedConfig = this.loadEdgeConfig();
                             console.log(`\n🔄 Reloading with ${updatedConfig.repositories?.length || 0} repositories from config file`);
                             return this.startEdgeWorker({
                                 proxyUrl,
-                                repositories: updatedConfig.repositories || []
+                                repositories: updatedConfig.repositories || [],
                             });
                         }
                         catch (error) {
-                            console.error('\n❌ Repository setup failed:', error.message);
+                            console.error("\n❌ Repository setup failed:", error.message);
                         }
                     }
-                }
-            }
+                },
+            },
         };
         // Create and start EdgeWorker
         this.edgeWorker = new EdgeWorker(config);
@@ -397,10 +419,10 @@ class EdgeApp {
         this.setupEventHandlers();
         // Start the worker
         await this.edgeWorker.start();
-        console.log('\n✅ Edge worker started successfully');
+        console.log("\n✅ Edge worker started successfully");
         console.log(`Configured proxy URL: ${config.proxyUrl}`);
         console.log(`Managing ${repositories.length} repositories:`);
-        repositories.forEach(repo => {
+        repositories.forEach((repo) => {
             console.log(`  - ${repo.name} (${repo.repositoryPath})`);
         });
     }
@@ -410,27 +432,28 @@ class EdgeApp {
     async start() {
         try {
             // Set proxy URL with default
-            const proxyUrl = process.env.PROXY_URL || 'https://cyrus-proxy.ceedar.workers.dev';
+            const proxyUrl = process.env.PROXY_URL || "https://cyrus-proxy.ceedar.workers.dev";
             // No need to validate Claude CLI - using Claude TypeScript SDK now
             // Load edge configuration
-            let edgeConfig = this.loadEdgeConfig();
+            const edgeConfig = this.loadEdgeConfig();
             let repositories = edgeConfig.repositories || [];
             // Check if we need to set up
             const needsSetup = repositories.length === 0;
-            const hasLinearCredentials = repositories.some(r => r.linearToken) || process.env.LINEAR_OAUTH_TOKEN;
+            const hasLinearCredentials = repositories.some((r) => r.linearToken) ||
+                process.env.LINEAR_OAUTH_TOKEN;
             if (needsSetup) {
-                console.log('🚀 Welcome to Cyrus Edge Worker!');
+                console.log("🚀 Welcome to Cyrus Edge Worker!");
                 // Check if they want to use existing credentials or add new workspace
                 let linearCredentials = null;
                 if (hasLinearCredentials) {
                     // Show available workspaces from existing repos
                     const workspaces = new Map();
-                    for (const repo of (edgeConfig.repositories || [])) {
+                    for (const repo of edgeConfig.repositories || []) {
                         if (!workspaces.has(repo.linearWorkspaceId)) {
                             workspaces.set(repo.linearWorkspaceId, {
                                 id: repo.linearWorkspaceId,
-                                name: 'Unknown Workspace',
-                                token: repo.linearToken
+                                name: "Unknown Workspace",
+                                token: repo.linearToken,
                             });
                         }
                     }
@@ -441,24 +464,24 @@ class EdgeApp {
                             linearCredentials = {
                                 linearToken: ws.token,
                                 linearWorkspaceId: ws.id,
-                                linearWorkspaceName: ws.name
+                                linearWorkspaceName: ws.name,
                             };
                             console.log(`\n📋 Using Linear workspace: ${linearCredentials.linearWorkspaceName}`);
                         }
                     }
                     else if (workspaces.size > 1) {
                         // Multiple workspaces, let user choose
-                        console.log('\n📋 Available Linear workspaces:');
+                        console.log("\n📋 Available Linear workspaces:");
                         const workspaceList = Array.from(workspaces.values());
                         workspaceList.forEach((ws, i) => {
                             console.log(`${i + 1}. ${ws.name}`);
                         });
                         const rl = readline.createInterface({
                             input: process.stdin,
-                            output: process.stdout
+                            output: process.stdout,
                         });
-                        const choice = await new Promise(resolve => {
-                            rl.question('\nSelect workspace (number) or press Enter for new: ', resolve);
+                        const choice = await new Promise((resolve) => {
+                            rl.question("\nSelect workspace (number) or press Enter for new: ", resolve);
                         });
                         rl.close();
                         const index = parseInt(choice) - 1;
@@ -468,7 +491,7 @@ class EdgeApp {
                                 linearCredentials = {
                                     linearToken: ws.token,
                                     linearWorkspaceId: ws.id,
-                                    linearWorkspaceName: ws.name
+                                    linearWorkspaceName: ws.name,
                                 };
                                 console.log(`Using workspace: ${linearCredentials.linearWorkspaceName}`);
                             }
@@ -482,56 +505,56 @@ class EdgeApp {
                         // Use env vars
                         linearCredentials = {
                             linearToken: process.env.LINEAR_OAUTH_TOKEN,
-                            linearWorkspaceId: process.env.LINEAR_WORKSPACE_ID || 'unknown',
-                            linearWorkspaceName: 'Your Workspace'
+                            linearWorkspaceId: process.env.LINEAR_WORKSPACE_ID || "unknown",
+                            linearWorkspaceName: "Your Workspace",
                         };
                     }
                     if (linearCredentials) {
-                        console.log('(OAuth server will start with EdgeWorker to connect additional workspaces)');
+                        console.log("(OAuth server will start with EdgeWorker to connect additional workspaces)");
                     }
                 }
                 else {
                     // Get new Linear credentials
-                    console.log('\n📋 Step 1: Connect to Linear');
-                    console.log('─'.repeat(50));
+                    console.log("\n📋 Step 1: Connect to Linear");
+                    console.log("─".repeat(50));
                     try {
                         linearCredentials = await this.startOAuthFlow(proxyUrl);
-                        console.log('\n✅ Linear connected successfully!');
+                        console.log("\n✅ Linear connected successfully!");
                     }
                     catch (error) {
-                        console.error('\n❌ OAuth flow failed:', error.message);
-                        console.log('\nAlternatively, you can:');
-                        console.log('1. Visit', `${proxyUrl}/oauth/authorize`, 'in your browser');
-                        console.log('2. Copy the token after authorization');
-                        console.log('3. Add it to your .env.cyrus file as LINEAR_OAUTH_TOKEN');
+                        console.error("\n❌ OAuth flow failed:", error.message);
+                        console.log("\nAlternatively, you can:");
+                        console.log("1. Visit", `${proxyUrl}/oauth/authorize`, "in your browser");
+                        console.log("2. Copy the token after authorization");
+                        console.log("3. Add it to your .env.cyrus file as LINEAR_OAUTH_TOKEN");
                         process.exit(1);
                     }
                 }
                 if (!linearCredentials) {
-                    console.error('❌ No Linear credentials available');
+                    console.error("❌ No Linear credentials available");
                     process.exit(1);
                 }
                 // Now set up repository
-                console.log('\n📋 Step 2: Configure Repository');
-                console.log('─'.repeat(50));
+                console.log("\n📋 Step 2: Configure Repository");
+                console.log("─".repeat(50));
                 try {
                     const newRepo = await this.setupRepositoryWizard(linearCredentials);
                     // Add to repositories
                     repositories = [...(edgeConfig.repositories || []), newRepo];
                     edgeConfig.repositories = repositories;
                     this.saveEdgeConfig(edgeConfig);
-                    console.log('\n✅ Repository configured successfully!');
-                    console.log('📝 ~/.cyrus/config.json file has been updated with your repository configuration.');
-                    console.log('💡 You can edit this file and restart Cyrus at any time to modify settings.');
+                    console.log("\n✅ Repository configured successfully!");
+                    console.log("📝 ~/.cyrus/config.json file has been updated with your repository configuration.");
+                    console.log("💡 You can edit this file and restart Cyrus at any time to modify settings.");
                     // Ask if they want to add another
                     const rl = readline.createInterface({
                         input: process.stdin,
-                        output: process.stdout
+                        output: process.stdout,
                     });
-                    const addAnother = await new Promise(resolve => {
-                        rl.question('\nAdd another repository? (y/N): ', answer => {
+                    const addAnother = await new Promise((resolve) => {
+                        rl.question("\nAdd another repository? (y/N): ", (answer) => {
                             rl.close();
-                            resolve(answer.toLowerCase() === 'y');
+                            resolve(answer.toLowerCase() === "y");
                         });
                     });
                     if (addAnother) {
@@ -540,14 +563,14 @@ class EdgeApp {
                     }
                 }
                 catch (error) {
-                    console.error('\n❌ Repository setup failed:', error.message);
+                    console.error("\n❌ Repository setup failed:", error.message);
                     process.exit(1);
                 }
             }
             // Validate we have repositories
             if (repositories.length === 0) {
-                console.error('❌ No repositories configured');
-                console.log('\nUse the authorization link above to configure your first repository.');
+                console.error("❌ No repositories configured");
+                console.log("\nUse the authorization link above to configure your first repository.");
                 process.exit(1);
             }
             // Start the edge worker
@@ -558,48 +581,75 @@ class EdgeApp {
             console.log(`\n🔐 OAuth server running on port ${serverPort}`);
             console.log(`👉 To authorize Linear (new workspace or re-auth):`);
             console.log(`   ${proxyUrl}/oauth/authorize?callback=${oauthCallbackBaseUrl}/callback`);
-            console.log('─'.repeat(70));
+            console.log("─".repeat(70));
             // Handle graceful shutdown
-            process.on('SIGINT', () => this.shutdown());
-            process.on('SIGTERM', () => this.shutdown());
+            process.on("SIGINT", () => this.shutdown());
+            process.on("SIGTERM", () => this.shutdown());
             // Handle uncaught exceptions and unhandled promise rejections
-            process.on('uncaughtException', (error) => {
-                console.error('🚨 Uncaught Exception:', error.message);
-                console.error('Error type:', error.constructor.name);
-                console.error('Stack:', error.stack);
-                console.error('This error was caught by the global handler, preventing application crash');
+            process.on("uncaughtException", (error) => {
+                console.error("🚨 Uncaught Exception:", error.message);
+                console.error("Error type:", error.constructor.name);
+                console.error("Stack:", error.stack);
+                console.error("This error was caught by the global handler, preventing application crash");
                 // Attempt graceful shutdown but don't wait indefinitely
                 this.shutdown().finally(() => {
-                    console.error('Process exiting due to uncaught exception');
+                    console.error("Process exiting due to uncaught exception");
                     process.exit(1);
                 });
             });
-            process.on('unhandledRejection', (reason, promise) => {
-                console.error('🚨 Unhandled Promise Rejection at:', promise);
-                console.error('Reason:', reason);
-                console.error('This rejection was caught by the global handler, continuing operation');
+            process.on("unhandledRejection", (reason, promise) => {
+                console.error("🚨 Unhandled Promise Rejection at:", promise);
+                console.error("Reason:", reason);
+                console.error("This rejection was caught by the global handler, continuing operation");
                 // Log stack trace if reason is an Error
                 if (reason instanceof Error && reason.stack) {
-                    console.error('Stack:', reason.stack);
+                    console.error("Stack:", reason.stack);
                 }
                 // Log the error but don't exit the process for promise rejections
                 // as they might be recoverable
             });
         }
         catch (error) {
-            console.error('\n❌ Failed to start edge application:', error.message);
+            console.error("\n❌ Failed to start edge application:", error.message);
             // Provide more specific guidance for common errors
-            if (error.message?.includes('Failed to connect any repositories')) {
-                console.error('\n💡 This usually happens when:');
-                console.error('   - All Linear OAuth tokens have expired');
-                console.error('   - The Linear API is temporarily unavailable');
-                console.error('   - Your network connection is having issues');
-                console.error('\nPlease check your edge configuration and try again.');
+            if (error.message?.includes("Failed to connect any repositories")) {
+                console.error("\n💡 This usually happens when:");
+                console.error("   - All Linear OAuth tokens have expired");
+                console.error("   - The Linear API is temporarily unavailable");
+                console.error("   - Your network connection is having issues");
+                console.error("\nPlease check your edge configuration and try again.");
             }
             await this.shutdown();
             process.exit(1);
         }
     }
+    /**
+     * Check if a branch exists locally or remotely
+     */
+    async branchExists(branchName, repoPath) {
+        const { execSync } = await import("node:child_process");
+        try {
+            // Check if branch exists locally
+            execSync(`git rev-parse --verify "${branchName}"`, {
+                cwd: repoPath,
+                stdio: "pipe",
+            });
+            return true;
+        }
+        catch {
+            // Branch doesn't exist locally, check remote
+            try {
+                execSync(`git ls-remote --heads origin "${branchName}"`, {
+                    cwd: repoPath,
+                    stdio: "pipe",
+                });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
     /**
      * Set up event handlers for EdgeWorker
      */
@@ -607,69 +657,70 @@ class EdgeApp {
         if (!this.edgeWorker)
             return;
         // Session events
-        this.edgeWorker.on('session:started', (issueId, _issue, repositoryId) => {
+        this.edgeWorker.on("session:started", (issueId, _issue, repositoryId) => {
             console.log(`Started session for issue ${issueId} in repository ${repositoryId}`);
         });
-        this.edgeWorker.on('session:ended', (issueId, exitCode, repositoryId) => {
+        this.edgeWorker.on("session:ended", (issueId, exitCode, repositoryId) => {
             console.log(`Session for issue ${issueId} ended with exit code ${exitCode} in repository ${repositoryId}`);
         });
         // Connection events
-        this.edgeWorker.on('connected', (token) => {
+        this.edgeWorker.on("connected", (token) => {
             console.log(`✅ Connected to proxy with token ending in ...${token.slice(-4)}`);
         });
-        this.edgeWorker.on('disconnected', (token, reason) => {
-            console.error(`❌ Disconnected from proxy (token ...${token.slice(-4)}): ${reason || 'Unknown reason'}`);
+        this.edgeWorker.on("disconnected", (token, reason) => {
+            console.error(`❌ Disconnected from proxy (token ...${token.slice(-4)}): ${reason || "Unknown reason"}`);
         });
         // Error events
-        this.edgeWorker.on('error', (error) => {
-            console.error('EdgeWorker error:', error);
+        this.edgeWorker.on("error", (error) => {
+            console.error("EdgeWorker error:", error);
         });
     }
     /**
      * Create a git worktree for an issue
      */
     async createGitWorktree(issue, repository) {
-        const { execSync } = await import('child_process');
-        const { existsSync } = await import('fs');
-        const { join } = await import('path');
+        const { execSync } = await import("node:child_process");
+        const { existsSync } = await import("node:fs");
+        const { join } = await import("node:path");
         try {
             // Verify this is a git repository
             try {
-                execSync('git rev-parse --git-dir', {
+                execSync("git rev-parse --git-dir", {
                     cwd: repository.repositoryPath,
-                    stdio: 'pipe'
+                    stdio: "pipe",
                 });
             }
-            catch (e) {
+            catch (_e) {
                 console.error(`${repository.repositoryPath} is not a git repository`);
-                throw new Error('Not a git repository');
+                throw new Error("Not a git repository");
             }
             // Sanitize branch name by removing backticks to prevent command injection
-            const sanitizeBranchName = (name) => name ? name.replace(/`/g, '') : name;
+            const sanitizeBranchName = (name) => name ? name.replace(/`/g, "") : name;
             // Use Linear's preferred branch name, or generate one if not available
-            const rawBranchName = issue.branchName || `${issue.identifier}-${issue.title?.toLowerCase().replace(/\s+/g, '-').substring(0, 30)}`;
+            const rawBranchName = issue.branchName ||
+                `${issue.identifier}-${issue.title?.toLowerCase().replace(/\s+/g, "-").substring(0, 30)}`;
             const branchName = sanitizeBranchName(rawBranchName);
             const workspacePath = join(repository.workspaceBaseDir, issue.identifier);
             // Ensure workspace directory exists
             execSync(`mkdir -p "${repository.workspaceBaseDir}"`, {
                 cwd: repository.repositoryPath,
-                stdio: 'pipe'
+                stdio: "pipe",
             });
             // Check if worktree already exists
             try {
-                const worktrees = execSync('git worktree list --porcelain', {
+                const worktrees = execSync("git worktree list --porcelain", {
                     cwd: repository.repositoryPath,
-                    encoding: 'utf-8'
+                    encoding: "utf-8",
                 });
                 if (worktrees.includes(workspacePath)) {
                     console.log(`Worktree already exists at ${workspacePath}, using existing`);
                     return {
                         path: workspacePath,
-                        isGitWorktree: true
+                        isGitWorktree: true,
                     };
                 }
             }
-            catch (e) {
+            catch (_e) {
                 // git worktree command failed, continue with creation
             }
             // Check if branch already exists
@@ -677,38 +728,65 @@ class EdgeApp {
             try {
                 execSync(`git rev-parse --verify "${branchName}"`, {
                     cwd: repository.repositoryPath,
-                    stdio: 'pipe'
+                    stdio: "pipe",
                 });
                 createBranch = false;
             }
-            catch (e) {
+            catch (_e) {
                 // Branch doesn't exist, we'll create it
             }
+            // Determine base branch for this issue
+            let baseBranch = repository.baseBranch;
+            // Check if issue has a parent
+            try {
+                const parent = await issue.parent;
+                if (parent) {
+                    console.log(`Issue ${issue.identifier} has parent: ${parent.identifier}`);
+                    // Get parent's branch name
+                    const parentRawBranchName = parent.branchName ||
+                        `${parent.identifier}-${parent.title?.toLowerCase().replace(/\s+/g, "-").substring(0, 30)}`;
+                    const parentBranchName = sanitizeBranchName(parentRawBranchName);
+                    // Check if parent branch exists
+                    const parentBranchExists = await this.branchExists(parentBranchName, repository.repositoryPath);
+                    if (parentBranchExists) {
+                        baseBranch = parentBranchName;
+                        console.log(`Using parent issue branch '${parentBranchName}' as base for sub-issue ${issue.identifier}`);
+                    }
+                    else {
+                        console.log(`Parent branch '${parentBranchName}' not found, using default base branch '${repository.baseBranch}'`);
+                    }
+                }
+            }
+            catch (_error) {
+                // Parent field might not exist or couldn't be fetched, use default base branch
+                console.log(`No parent issue found for ${issue.identifier}, using default base branch '${repository.baseBranch}'`);
+            }
             // Fetch latest changes from remote
-            console.log('Fetching latest changes from remote...');
+            console.log("Fetching latest changes from remote...");
             let hasRemote = true;
             try {
-                execSync('git fetch origin', {
+                execSync("git fetch origin", {
                     cwd: repository.repositoryPath,
-                    stdio: 'pipe'
+                    stdio: "pipe",
                 });
             }
             catch (e) {
-                console.warn('Warning: git fetch failed, proceeding with local branch:', e.message);
+                console.warn("Warning: git fetch failed, proceeding with local branch:", e.message);
                 hasRemote = false;
             }
-            // Create the worktree - use remote branch if available, otherwise local
+            // Create the worktree - use determined base branch
             let worktreeCmd;
             if (createBranch) {
                 if (hasRemote) {
-                    const remoteBranch = `origin/${repository.baseBranch}`;
+                    // Always prefer remote version if available
+                    const remoteBranch = `origin/${baseBranch}`;
                     console.log(`Creating git worktree at ${workspacePath} from ${remoteBranch}`);
                     worktreeCmd = `git worktree add "${workspacePath}" -b "${branchName}" "${remoteBranch}"`;
                 }
                 else {
-                    // No remote, use local base branch
-                    console.log(`Creating git worktree at ${workspacePath} from local ${repository.baseBranch}`);
-                    worktreeCmd = `git worktree add "${workspacePath}" -b "${branchName}" "${repository.baseBranch}"`;
+                    // No remote, use local branch
+                    console.log(`Creating git worktree at ${workspacePath} from local ${baseBranch}`);
+                    worktreeCmd = `git worktree add "${workspacePath}" -b "${branchName}" "${baseBranch}"`;
                 }
             }
             else {
@@ -718,42 +796,42 @@ class EdgeApp {
             }
             execSync(worktreeCmd, {
                 cwd: repository.repositoryPath,
-                stdio: 'pipe'
+                stdio: "pipe",
             });
             // Check for cyrus-setup.sh script in the repository root
-            const setupScriptPath = join(repository.repositoryPath, 'cyrus-setup.sh');
+            const setupScriptPath = join(repository.repositoryPath, "cyrus-setup.sh");
             if (existsSync(setupScriptPath)) {
-                console.log('Running cyrus-setup.sh in new worktree...');
+                console.log("Running cyrus-setup.sh in new worktree...");
                 try {
-                    execSync('bash cyrus-setup.sh', {
+                    execSync("bash cyrus-setup.sh", {
                         cwd: workspacePath,
-                        stdio: 'inherit',
+                        stdio: "inherit",
                         env: {
                             ...process.env,
                             LINEAR_ISSUE_ID: issue.id,
                             LINEAR_ISSUE_IDENTIFIER: issue.identifier,
-                            LINEAR_ISSUE_TITLE: issue.title || ''
-                        }
+                            LINEAR_ISSUE_TITLE: issue.title || "",
+                        },
                     });
                 }
                 catch (error) {
-                    console.warn('Warning: cyrus-setup.sh failed:', error.message);
+                    console.warn("Warning: cyrus-setup.sh failed:", error.message);
                     // Continue despite setup script failure
                 }
             }
             return {
                 path: workspacePath,
-                isGitWorktree: true
+                isGitWorktree: true,
             };
         }
         catch (error) {
-            console.error('Failed to create git worktree:', error.message);
+            console.error("Failed to create git worktree:", error.message);
             // Fall back to regular directory if git worktree fails
             const fallbackPath = join(repository.workspaceBaseDir, issue.identifier);
-            execSync(`mkdir -p "${fallbackPath}"`, { stdio: 'pipe' });
+            execSync(`mkdir -p "${fallbackPath}"`, { stdio: "pipe" });
             return {
                 path: fallbackPath,
-                isGitWorktree: false
+                isGitWorktree: false,
             };
         }
     }
@@ -764,31 +842,34 @@ class EdgeApp {
         if (this.isShuttingDown)
             return;
         this.isShuttingDown = true;
-        console.log('\nShutting down edge worker...');
+        console.log("\nShutting down edge worker...");
         // Stop edge worker (includes stopping shared application server)
         if (this.edgeWorker) {
             await this.edgeWorker.stop();
         }
-        console.log('Shutdown complete');
+        console.log("Shutdown complete");
         process.exit(0);
     }
 }
 // Helper function to check Linear token status
 async function checkLinearToken(token) {
     try {
-        const response = await fetch('https://api.linear.app/graphql', {
-            method: 'POST',
+        const response = await fetch("https://api.linear.app/graphql", {
+            method: "POST",
             headers: {
-                'Content-Type': 'application/json',
-                'Authorization': token
+                "Content-Type": "application/json",
+                Authorization: token,
             },
             body: JSON.stringify({
-                query: '{ viewer { id email name } }'
-            })
+                query: "{ viewer { id email name } }",
+            }),
         });
-        const data = await response.json();
+        const data = (await response.json());
         if (data.errors) {
-            return { valid: false, error: data.errors[0]?.message || 'Unknown error' };
+            return {
+                valid: false,
+                error: data.errors[0]?.message || "Unknown error",
+            };
         }
         return { valid: true };
     }
@@ -801,16 +882,16 @@ async function checkTokensCommand() {
     const app = new EdgeApp();
     const configPath = app.getEdgeConfigPath();
     if (!existsSync(configPath)) {
-        console.error('No edge configuration found. Please run setup first.');
+        console.error("No edge configuration found. Please run setup first.");
         process.exit(1);
     }
-    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    console.log('Checking Linear tokens...\n');
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    console.log("Checking Linear tokens...\n");
     for (const repo of config.repositories) {
         process.stdout.write(`${repo.name} (${repo.linearWorkspaceName}): `);
         const result = await checkLinearToken(repo.linearToken);
         if (result.valid) {
-            console.log('✅ Valid');
+            console.log("✅ Valid");
         }
         else {
             console.log(`❌ Invalid - ${result.error}`);
@@ -822,34 +903,34 @@ async function refreshTokenCommand() {
     const app = new EdgeApp();
     const configPath = app.getEdgeConfigPath();
     if (!existsSync(configPath)) {
-        console.error('No edge configuration found. Please run setup first.');
+        console.error("No edge configuration found. Please run setup first.");
         process.exit(1);
     }
-    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
     // Show repositories with their token status
-    console.log('Checking current token status...\n');
+    console.log("Checking current token status...\n");
     const tokenStatuses = [];
     for (const repo of config.repositories) {
         const result = await checkLinearToken(repo.linearToken);
         tokenStatuses.push({ repo, valid: result.valid });
-        console.log(`${tokenStatuses.length}. ${repo.name} (${repo.linearWorkspaceName}): ${result.valid ? '✅ Valid' : '❌ Invalid'}`);
+        console.log(`${tokenStatuses.length}. ${repo.name} (${repo.linearWorkspaceName}): ${result.valid ? "✅ Valid" : "❌ Invalid"}`);
     }
     // Ask which token to refresh
     const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout
+        output: process.stdout,
     });
-    const answer = await new Promise(resolve => {
+    const answer = await new Promise((resolve) => {
         rl.question('\nWhich repository token would you like to refresh? (Enter number or "all"): ', resolve);
     });
     const indicesToRefresh = [];
-    if (answer.toLowerCase() === 'all') {
+    if (answer.toLowerCase() === "all") {
         indicesToRefresh.push(...Array.from({ length: tokenStatuses.length }, (_, i) => i));
     }
     else {
         const index = parseInt(answer) - 1;
-        if (isNaN(index) || index < 0 || index >= tokenStatuses.length) {
-            console.error('Invalid selection');
+        if (Number.isNaN(index) || index < 0 || index >= tokenStatuses.length) {
+            console.error("Invalid selection");
             rl.close();
             process.exit(1);
         }
@@ -862,9 +943,11 @@ async function refreshTokenCommand() {
             continue;
         const { repo } = tokenStatus;
         console.log(`\nRefreshing token for ${repo.name} (${repo.linearWorkspaceName || repo.linearWorkspaceId})...`);
-        console.log('Opening Linear OAuth flow in your browser...');
+        console.log("Opening Linear OAuth flow in your browser...");
         // Use the proxy's OAuth flow with a callback to localhost
-        const serverPort = process.env.CYRUS_SERVER_PORT ? parseInt(process.env.CYRUS_SERVER_PORT, 10) : 3456;
+        const serverPort = process.env.CYRUS_SERVER_PORT
+            ? parseInt(process.env.CYRUS_SERVER_PORT, 10)
+            : 3456;
         const callbackUrl = `http://localhost:${serverPort}/callback`;
         const oauthUrl = `https://cyrus-proxy.ceedar.workers.dev/oauth/authorize?callback=${encodeURIComponent(callbackUrl)}`;
         console.log(`\nPlease complete the OAuth flow in your browser.`);
@@ -873,10 +956,10 @@ async function refreshTokenCommand() {
         let tokenReceived = null;
         const server = await new Promise((resolve) => {
             const s = http.createServer((req, res) => {
-                if (req.url?.startsWith('/callback')) {
+                if (req.url?.startsWith("/callback")) {
                     const url = new URL(req.url, `http://localhost:${serverPort}`);
-                    tokenReceived = url.searchParams.get('token');
-                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    tokenReceived = url.searchParams.get("token");
+                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
                     res.end(`
             <html>
               <head>
@@ -892,11 +975,11 @@ async function refreshTokenCommand() {
                 }
                 else {
                     res.writeHead(404);
-                    res.end('Not found');
+                    res.end("Not found");
                 }
             });
             s.listen(serverPort, () => {
-                console.log('Waiting for OAuth callback...');
+                console.log("Waiting for OAuth callback...");
                 resolve(s);
             });
         });
@@ -904,12 +987,12 @@ async function refreshTokenCommand() {
         // Wait for the token with timeout
         const startTime = Date.now();
         while (!tokenReceived && Date.now() - startTime < 120000) {
-            await new Promise(resolve => setTimeout(resolve, 100));
+            await new Promise((resolve) => setTimeout(resolve, 100));
         }
         server.close();
         const newToken = tokenReceived;
-        if (!newToken || !newToken.startsWith('lin_oauth_')) {
-            console.error('Invalid token received from OAuth flow');
+        if (!newToken || !newToken.startsWith("lin_oauth_")) {
+            console.error("Invalid token received from OAuth flow");
             continue;
         }
         // Verify the new token
@@ -935,33 +1018,33 @@ async function refreshTokenCommand() {
     }
     // Save the updated config
     writeFileSync(configPath, JSON.stringify(config, null, 2));
-    console.log('\n✅ Configuration saved');
+    console.log("\n✅ Configuration saved");
     rl.close();
 }
 // Parse command
-const command = args[0] || 'start';
+const command = args[0] || "start";
 // Execute appropriate command
 switch (command) {
-    case 'check-tokens':
-        checkTokensCommand().catch(error => {
-            console.error('Error:', error);
+    case "check-tokens":
+        checkTokensCommand().catch((error) => {
+            console.error("Error:", error);
             process.exit(1);
         });
         break;
-    case 'refresh-token':
-        refreshTokenCommand().catch(error => {
-            console.error('Error:', error);
+    case "refresh-token":
+        refreshTokenCommand().catch((error) => {
+            console.error("Error:", error);
             process.exit(1);
         });
         break;
-    case 'start':
-    default:
+    default: {
         // Create and start the app
         const app = new EdgeApp();
-        app.start().catch(error => {
-            console.error('Fatal error:', error);
+        app.start().catch((error) => {
+            console.error("Fatal error:", error);
             process.exit(1);
         });
         break;
+    }
 }
 //# sourceMappingURL=app.js.map