s9n-devops-agent 2.0.18-dev.0 → 2.0.18-dev.11

package/src/agent-chat.js

@@ -23,7 +23,7 @@ import readline from 'readline';
 import Groq from 'groq-sdk';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import { credentialsManager } from './credentials-manager.js';
 import HouseRulesManager from './house-rules-manager.js';
 // We'll import SessionCoordinator dynamically to avoid circular deps if any
@@ -51,9 +51,14 @@ const CONFIG = {
 
 class SmartAssistant {
   constructor() {
-    this.groq = new Groq({
-      apiKey: process.env.GROQ_API_KEY || process.env.OPENAI_API_KEY
-    });
+    // Initialize Groq client lazily or with null if key is missing
+    const apiKey = process.env.GROQ_API_KEY || process.env.OPENAI_API_KEY;
+    
+    if (apiKey) {
+      this.groq = new Groq({ apiKey });
+    } else {
+      this.groq = null; // Will be initialized in start()
+    }
     
     this.history = [];
     this.repoRoot = process.cwd();
@@ -99,10 +104,50 @@ class SmartAssistant {
           description: "Check the status of active sessions and locks",
           parameters: { type: "object", properties: {} }
         }
+      },
+      {
+        type: "function",
+        function: {
+          name: "resume_session",
+          description: "Resume an existing or orphaned session",
+          parameters: {
+            type: "object",
+            properties: {
+              sessionId: { type: "string", description: "The ID of the session to resume" },
+              taskName: { type: "string", description: "The task name to search for (optional)" }
+            },
+            required: ["sessionId"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "recover_sessions",
+          description: "Scan for and recover orphaned sessions from existing worktrees",
+          parameters: { type: "object", properties: {} }
+        }
       }
     ];
 
-    this.systemPrompt = `You are Kora, the Smart DevOps Assistant. 
+    // Load skills definition
+    let skillsDef = null;
+    try {
+      const skillsPath = path.join(__dirname, 'kora-skills.json');
+      if (fs.existsSync(skillsPath)) {
+        skillsDef = JSON.parse(fs.readFileSync(skillsPath, 'utf8'));
+      }
+    } catch (e) {
+      // Fallback if file missing or invalid
+      console.error('Warning: Could not load kora-skills.json, using defaults.');
+    }
+
+    if (skillsDef) {
+        // Build dynamic system prompt from skills definition
+        const allowedTopics = skillsDef.guardrails.allowed_topics.map(t => `- ${t}`).join('\n');
+        const disallowedTopics = skillsDef.guardrails.disallowed_topics.map(t => `- ${t}`).join('\n');
+        
+        this.systemPrompt = `You are ${skillsDef.assistant_name}, the ${skillsDef.role}.
 Your goal is to help developers follow the House Rules and Contract System while being helpful and efficient.
 
 CONTEXT:
@@ -111,22 +156,81 @@ CONTEXT:
 - Users need to create "Sessions" to do work.
 - You can execute tools to help the user.
 
-STYLE:
+CAPABILITIES (ALLOWED):
+${allowedTopics}
+
+GUARDRAILS (STRICTLY PROHIBITED):
+${disallowedTopics}
+
+AVAILABLE TOOLS:
+1. get_house_rules_summary - Read the project's rules.
+2. list_contracts - Check what contract files exist.
+3. check_session_status - See active work sessions.
+4. start_session - Begin a new task.
+5. resume_session - Resume an existing or orphaned session.
+6. recover_sessions - Scan and restore lost session locks.
+
+IMPORTANT INSTRUCTIONS:
+- ONLY use the tools listed above. Do NOT invent new tools like "check_compliance" or "run_tests".
+- If the user asks for something OUTSIDE your capabilities, you MUST reply with exactly this message:
+  "${skillsDef.guardrails.fallback_response}"
+- Be concise but helpful.
+- Identify yourself as "${skillsDef.assistant_name}".
+- If the user asks about starting a task, ask for a clear task name if not provided.
+- If the user asks about rules, summarize them from the actual files.
+- If the user wants to resume work, use check_session_status first.
+- If a session seems missing but worktree exists, use recover_sessions.
+- Always prefer "Structured" organization for new code.
+
+When you want to perform an action, use the available tools.`;
+    } else {
+        // Fallback static prompt
+        this.systemPrompt = `You are Kora, the Smart DevOps Assistant. 
+Your goal is to help developers follow the House Rules and Contract System while being helpful and efficient.
+
+CONTEXT:
+- You are running inside a "DevOps Agent" environment.
+- The project follows a strict "Contract System" (API, DB, Features, etc.).
+- Users need to create "Sessions" to do work.
+- You can execute tools to help the user.
+
+AVAILABLE TOOLS:
+1. get_house_rules_summary - Read the project's rules.
+2. list_contracts - Check what contract files exist.
+3. check_session_status - See active work sessions.
+4. start_session - Begin a new task.
+5. resume_session - Resume an existing or orphaned session.
+6. recover_sessions - Scan and restore lost session locks.
+
+IMPORTANT INSTRUCTIONS:
+- ONLY use the tools listed above. Do NOT invent new tools like "check_compliance" or "run_tests".
+- If a user asks for something you can't do with a tool (like running tests), tell them you can't do it yet but they can run "npm test" themselves.
 - Be concise but helpful.
 - Identify yourself as "Kora".
 - If the user asks about starting a task, ask for a clear task name if not provided.
 - If the user asks about rules, summarize them from the actual files.
+- If the user wants to resume work, use check_session_status first.
+- If a session seems missing but worktree exists, use recover_sessions.
 - Always prefer "Structured" organization for new code.
 
 When you want to perform an action, use the available tools.`;
+    }
   }
 
   /**
    * Initialize the chat session
    */
   async start() {
+    // Ensure Groq client is initialized
+    if (!this.groq) {
+      const apiKey = credentialsManager.getGroqApiKey();
+      if (apiKey) {
+        this.groq = new Groq({ apiKey });
+      }
+    }
+
     // Check for Groq API Key
-    if (!credentialsManager.hasGroqApiKey()) {
+    if (!this.groq && !credentialsManager.hasGroqApiKey()) {
       console.log('\n' + '='.repeat(60));
       console.log(`${CONFIG.colors.yellow}⚠️  GROQ API KEY MISSING${CONFIG.colors.reset}`);
       console.log('='.repeat(60));
@@ -171,6 +275,41 @@ When you want to perform an action, use the available tools.`;
     console.log(`\n${CONFIG.colors.cyan}Hi! I'm Kora. How can I help you today?${CONFIG.colors.reset}`);
     console.log(`${CONFIG.colors.dim}(Try: "Start a new task for login", "Explain house rules", "Check contracts")${CONFIG.colors.reset}\n`);
 
+    // Check for command line arguments
+    const args = process.argv.slice(2);
+    const taskIndex = args.indexOf('--task') !== -1 ? args.indexOf('--task') : args.indexOf('-t');
+    
+    if (taskIndex !== -1 && args[taskIndex + 1]) {
+      const taskName = args[taskIndex + 1];
+      console.log(`\n${CONFIG.colors.cyan}Auto-starting session for task: ${taskName}${CONFIG.colors.reset}\n`);
+      await this.startSession({ taskName });
+      return; // Exit after session? Or continue chat? Usually session start spawns child and returns.
+      // startSession re-initializes readline after child exit, so we can continue chat.
+    }
+
+    // Check for auto-resume
+    const resumeIndex = args.indexOf('resume');
+    const sessionIdIndex = args.indexOf('--session-id');
+    
+    if (resumeIndex !== -1 || sessionIdIndex !== -1) {
+      let sessionId = null;
+      let taskName = null;
+      
+      if (sessionIdIndex !== -1 && args[sessionIdIndex + 1]) {
+        sessionId = args[sessionIdIndex + 1];
+      }
+      
+      if (taskIndex !== -1 && args[taskIndex + 1]) {
+        taskName = args[taskIndex + 1];
+      }
+      
+      if (sessionId || taskName) {
+        console.log(`\n${CONFIG.colors.cyan}Auto-resuming session...${CONFIG.colors.reset}\n`);
+        await this.resumeSession({ sessionId, taskName });
+        return;
+      }
+    }
+
     this.startReadline();
   }
 
@@ -292,6 +431,12 @@ When you want to perform an action, use the available tools.`;
           case 'start_session':
             result = await this.startSession(args);
             break;
+          case 'resume_session':
+            result = await this.resumeSession(args);
+            break;
+          case 'recover_sessions':
+            result = await this.recoverSessions();
+            break;
           default:
             result = JSON.stringify({ error: "Unknown tool" });
         }
@@ -351,15 +496,50 @@ When you want to perform an action, use the available tools.`;
 
   async listContracts() {
     const contractsDir = path.join(this.repoRoot, 'House_Rules_Contracts');
-    if (!fs.existsSync(contractsDir)) {
-      return JSON.stringify({ exists: false, message: "Contracts folder not found." });
+    const centralExists = fs.existsSync(contractsDir);
+    
+    // Recursive search for contracts (similar to setup script)
+    const findCommand = `find "${this.repoRoot}" -type f \\( -iname "*CONTRACT*.md" -o -iname "*CONTRACT*.json" \\) -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/local_deploy/*"`;
+    
+    let allFiles = [];
+    try {
+        const output = execSync(findCommand, { encoding: 'utf8' }).trim();
+        allFiles = output.split('\n').filter(Boolean);
+    } catch (e) {
+        // Find failed or no files
     }
 
-    const files = fs.readdirSync(contractsDir).filter(f => f.endsWith('.md') || f.endsWith('.json'));
-    return JSON.stringify({
-      exists: true,
-      files: files,
-      location: contractsDir
+    const requiredTypes = [
+      'FEATURES_CONTRACT.md', 'API_CONTRACT.md', 'DATABASE_SCHEMA_CONTRACT.md',
+      'SQL_CONTRACT.json', 'THIRD_PARTY_INTEGRATIONS.md', 'INFRA_CONTRACT.md'
+    ];
+
+    const status = {};
+    let scatteredCount = 0;
+    
+    requiredTypes.forEach(type => {
+        // Check if in central folder
+        const isCentral = fs.existsSync(path.join(contractsDir, type));
+        
+        // Check if anywhere in repo
+        const found = allFiles.filter(f => path.basename(f).toUpperCase() === type || path.basename(f).toUpperCase().includes(type.split('.')[0]));
+        
+        status[type] = {
+            central: isCentral,
+            foundCount: found.length,
+            locations: found.map(f => path.relative(this.repoRoot, f))
+        };
+        
+        if (!isCentral && found.length > 0) scatteredCount++;
+    });
+
+    return JSON.stringify({ 
+      centralFolderExists: centralExists,
+      scatteredContractsCount: scatteredCount,
+      details: status,
+      message: scatteredCount > 0 
+        ? "Contracts found scattered in repository. Recommend running 'npm run setup' to consolidate." 
+        : (centralExists ? "Contracts found in central folder." : "No contracts found.")
     });
   }
 
@@ -391,55 +571,138 @@ When you want to perform an action, use the available tools.`;
   }
 
   async startSession(args) {
-    const taskName = args.taskName;
+    const { taskName, description } = args;
     
-    console.log(`${CONFIG.colors.magenta}Kora > ${CONFIG.colors.reset}Starting new session for: ${taskName}...`);
+    console.log(`${CONFIG.colors.magenta}Kora > ${CONFIG.colors.reset}Starting session for task: ${taskName}...`);
     
-    // Close readline interface to release stdin for the child process
+    // Close readline interface
     if (this.rl) {
       this.rl.close();
       this.rl = null;
     }
 
-    // We need to run the session coordinator interactively
-    // We'll use the 'create-and-start' command to jump straight to the task
     const scriptPath = path.join(__dirname, 'session-coordinator.js');
     
     return new Promise((resolve, reject) => {
-      // Use 'inherit' for stdio to allow interactive input/output
       const child = spawn('node', [scriptPath, 'create-and-start', '--task', taskName], {
         stdio: 'inherit',
         cwd: this.repoRoot
       });
       
       child.on('close', (code) => {
-        // Re-initialize readline interface after child process exits
         this.startReadline();
+        if (code === 0) {
+          resolve(JSON.stringify({ success: true, message: "Session started successfully." }));
+        } else {
+          resolve(JSON.stringify({ success: false, message: `Session process exited with code ${code}.` }));
+        }
+        console.log(`\n${CONFIG.colors.cyan}Welcome back to Kora!${CONFIG.colors.reset}`);
+      });
+      
+      child.on('error', (err) => {
+        this.startReadline();
+        resolve(JSON.stringify({ success: false, error: err.message }));
+      });
+    });
+  }
 
+  async recoverSessions() {
+    console.log(`${CONFIG.colors.magenta}Kora > ${CONFIG.colors.reset}Scanning for orphaned sessions to recover...`);
+    
+    // Close readline interface
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+
+    const scriptPath = path.join(__dirname, 'session-coordinator.js');
+    
+    return new Promise((resolve, reject) => {
+      const child = spawn('node', [scriptPath, 'recover'], {
+        stdio: 'inherit',
+        cwd: this.repoRoot
+      });
+      
+      child.on('close', (code) => {
+        this.startReadline();
         if (code === 0) {
-          resolve(JSON.stringify({
-            success: true,
-            message: `Session for '${taskName}' completed successfully.`
+          // Instead of generic message, suggest checking status
+          resolve(JSON.stringify({ 
+            success: true, 
+            message: "Recovery scan complete. Please run 'check_session_status' to see recovered sessions." 
           }));
         } else {
-          resolve(JSON.stringify({
-            success: false,
-            message: `Session process exited with code ${code}.`
-          }));
+          resolve(JSON.stringify({ success: false, message: `Recovery process exited with code ${code}.` }));
+        }
+        // Don't print "Welcome back" here to keep flow cleaner
+      });
+      
+      child.on('error', (err) => {
+        this.startReadline();
+        resolve(JSON.stringify({ success: false, error: err.message }));
+      });
+    });
+  }
+  async resumeSession(args) {
+    const { sessionId, taskName } = args;
+    
+    console.log(`${CONFIG.colors.magenta}Kora > ${CONFIG.colors.reset}Resuming session: ${sessionId || taskName}...`);
+    
+    // Close readline interface
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+
+    const scriptPath = path.join(__dirname, 'session-coordinator.js');
+    
+    // Construct arguments for session coordinator
+    // We use the 'resume' command if we have an ID, or create-and-start with task if we're fuzzy matching
+    // But actually session-coordinator doesn't have a direct 'resume' command exposed easily via CLI args 
+    // that jumps straight to monitoring without prompts, EXCEPT via the way createSession handles existing sessions.
+    // However, createSession with --task will prompt.
+    // Let's use a new approach: pass --resume-session-id if we have it.
+    
+    // Wait, session-coordinator.js CLI handling (which I can't fully see but I saw 'create' and 'list')
+    // I need to check how to invoke resume.
+    // Looking at session-coordinator.js (which I read), it has 'requestSession' and 'createSession'.
+    // It doesn't seem to have a direct CLI command for 'resume' that takes an ID.
+    // However, 'create-and-start' (implied by startSession usage) might support it?
+    // In startSession: [scriptPath, 'create-and-start', '--task', taskName, '--skip-setup', '--skip-update']
+    
+    // If I use 'create-and-start' with the SAME task name, it triggers the "Found existing session" logic
+    // but that logic is interactive (prompts Y/n).
+    
+    // I should probably add a CLI command to session-coordinator.js to resume by ID non-interactively,
+    // OR just use the 'worker' command directly if I know the worktree?
+    // But the coordinator handles setting up the environment.
+    
+    // Let's assume for now we can use a new 'resume' command in session-coordinator.js
+    // I will need to implement that in session-coordinator.js as well.
+    // But first let's implement the caller here.
+    
+    const cmdArgs = ['resume', '--session-id', sessionId];
+    if (taskName) cmdArgs.push('--task', taskName);
+    
+    return new Promise((resolve, reject) => {
+      const child = spawn('node', [scriptPath, ...cmdArgs], {
+        stdio: 'inherit',
+        cwd: this.repoRoot
+      });
+      
+      child.on('close', (code) => {
+        this.startReadline();
+        if (code === 0) {
+          resolve(JSON.stringify({ success: true, message: "Session resumed successfully." }));
+        } else {
+          resolve(JSON.stringify({ success: false, message: `Session process exited with code ${code}.` }));
         }
-        
-        // Resume the chat interface after the child process exits
         console.log(`\n${CONFIG.colors.cyan}Welcome back to Kora!${CONFIG.colors.reset}`);
       });
       
       child.on('error', (err) => {
-        // Re-initialize readline interface on error
         this.startReadline();
-        
-        resolve(JSON.stringify({
-          success: false,
-          error: err.message
-        }));
+        resolve(JSON.stringify({ success: false, error: err.message }));
       });
     });
   }

package/src/credentials-manager.js

@@ -3,11 +3,15 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 
+import os from 'os';
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const rootDir = path.join(__dirname, '..');
 
-const CREDENTIALS_PATH = process.env.DEVOPS_CREDENTIALS_PATH || path.join(rootDir, 'local_deploy', 'credentials.json');
+// Use home directory for persistent storage across package updates
+const HOME_DIR = os.homedir();
+const CONFIG_DIR = path.join(HOME_DIR, '.devops-agent');
+const CREDENTIALS_PATH = process.env.DEVOPS_CREDENTIALS_PATH || path.join(CONFIG_DIR, 'credentials.json');
 
 // Simple obfuscation to prevent casual shoulder surfing
 // NOTE: This is NOT strong encryption. In a production environment with sensitive keys,
@@ -38,15 +42,33 @@ export class CredentialsManager {
         console.error('Failed to load credentials:', error.message);
         this.credentials = {};
       }
+    } else {
+        // Migration: Check for old local_deploy location
+        const oldPath = path.join(__dirname, '..', 'local_deploy', 'credentials.json');
+        if (fs.existsSync(oldPath)) {
+            try {
+                const rawData = fs.readFileSync(oldPath, 'utf8');
+                const data = JSON.parse(rawData);
+                 // Deobfuscate sensitive values
+                if (data.groqApiKey) {
+                    data.groqApiKey = deobfuscate(data.groqApiKey);
+                }
+                this.credentials = data;
+                // Save to new location immediately
+                this.save();
+            } catch (e) {
+                // Ignore migration errors
+            }
+        }
     }
   }
 
   save() {
     try {
-      // Ensure local_deploy exists
-      const localDeployDir = path.dirname(CREDENTIALS_PATH);
-      if (!fs.existsSync(localDeployDir)) {
-        fs.mkdirSync(localDeployDir, { recursive: true });
+      // Ensure config dir exists
+      const configDir = path.dirname(CREDENTIALS_PATH);
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
       }
 
       // Clone and obfuscate