shark-ai 0.2.0 → 0.2.1

package/dist/bin/shark.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
   ConfigManager,
+  FileLogger,
   colors,
   configCommand,
   loginCommand,
   tokenStorage,
   tui
-} from "../chunk-4UPBRJYA.js";
+} from "../chunk-R3MIUNVD.js";
 
 // src/core/error/crash-handler.ts
 import fs from "fs";
@@ -267,41 +268,6 @@ var initCommand = new Command("init").description("Initialize a new Shark projec
 // src/core/api/stackspot-client.ts
 var STACKSPOT_AGENT_API_BASE = "https://genai-inference-app.stackspot.com";
 
-// src/core/debug/file-logger.ts
-import fs3 from "fs";
-import path3 from "path";
-var FileLogger = class {
-  static logPath = path3.resolve(process.cwd(), "shark-debug.log");
-  static enabled = true;
-  // Enabled by default for this debugging session
-  static init() {
-    try {
-      fs3.writeFileSync(this.logPath, `--- Shark CLI Debug Log Started at ${(/* @__PURE__ */ new Date()).toISOString()} ---
-`);
-    } catch (e) {
-      console.error("Failed to initialize debug log:", e);
-    }
-  }
-  static log(category, message, data) {
-    if (!this.enabled) return;
-    try {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      let logEntry = `[${timestamp}] [${category.toUpperCase()}] ${message}
-`;
-      if (data !== void 0) {
-        if (typeof data === "object") {
-          logEntry += JSON.stringify(data, null, 2) + "\n";
-        } else {
-          logEntry += String(data) + "\n";
-        }
-      }
-      logEntry += "-".repeat(40) + "\n";
-      fs3.appendFileSync(this.logPath, logEntry);
-    } catch (e) {
-    }
-  }
-};
-
 // src/core/api/sse-client.ts
 var SSEClient = class {
   /**
@@ -760,17 +726,17 @@ async function interactiveBusinessAnalyst() {
 }
 
 // src/core/agents/specification-agent.ts
-import fs5 from "fs";
+import fs4 from "fs";
 
 // src/core/agents/agent-tools.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import fg from "fast-glob";
 function handleListFiles(dirPath) {
   try {
-    const fullPath = path4.resolve(process.cwd(), dirPath);
-    if (!fs4.existsSync(fullPath)) return `Error: Directory ${dirPath} does not exist.`;
-    const items = fs4.readdirSync(fullPath, { withFileTypes: true });
+    const fullPath = path3.resolve(process.cwd(), dirPath);
+    if (!fs3.existsSync(fullPath)) return `Error: Directory ${dirPath} does not exist.`;
+    const items = fs3.readdirSync(fullPath, { withFileTypes: true });
     return items.map((item) => {
       return `${item.isDirectory() ? "[DIR]" : "[FILE]"} ${item.name}`;
     }).join("\n");
@@ -780,11 +746,11 @@ function handleListFiles(dirPath) {
 }
 function handleReadFile(filePath) {
   try {
-    const fullPath = path4.resolve(process.cwd(), filePath);
-    if (!fs4.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
-    const stats = fs4.statSync(fullPath);
+    const fullPath = path3.resolve(process.cwd(), filePath);
+    if (!fs3.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
+    const stats = fs3.statSync(fullPath);
     if (stats.size > 100 * 1024) return `Error: File too large to read (${stats.size} bytes). Limit is 100KB.`;
-    return fs4.readFileSync(fullPath, "utf-8");
+    return fs3.readFileSync(fullPath, "utf-8");
   } catch (e) {
     return `Error reading file: ${e.message}`;
   }
@@ -799,11 +765,11 @@ function handleSearchFile(pattern) {
   }
 }
 function startSmartReplace(filePath, newContent, targetContent, tui2) {
-  if (!fs4.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     tui2.log.error(`\u274C File not found for modification: ${filePath}`);
     return false;
   }
-  const currentFileContent = fs4.readFileSync(filePath, "utf-8");
+  const currentFileContent = fs3.readFileSync(filePath, "utf-8");
   if (!currentFileContent.includes(targetContent)) {
     tui2.log.error(`\u274C Target content not found in ${filePath}. Modification aborted.`);
     console.log(colors.dim("--- Target Content Expected ---"));
@@ -816,7 +782,7 @@ function startSmartReplace(filePath, newContent, targetContent, tui2) {
     return false;
   }
   const updatedContent = currentFileContent.replace(targetContent, newContent);
-  fs4.writeFileSync(filePath, updatedContent);
+  fs3.writeFileSync(filePath, updatedContent);
   tui2.log.success(`\u2705 Smart Replace Applied: ${filePath}`);
   return true;
 }
@@ -877,21 +843,21 @@ async function interactiveSpecificationAgent(options = {}) {
   let briefingContent = "";
   let briefingPath = options.briefingPath;
   if (!briefingPath) {
-    const files = fs5.readdirSync(process.cwd());
+    const files = fs4.readdirSync(process.cwd());
     const defaultBriefing = files.find((f) => f.endsWith("_briefing.md"));
     briefingPath = await tui.text({
       message: "Path to Briefing file (Leave empty to skip)",
       initialValue: defaultBriefing || "",
       placeholder: "e.g., todo-list_briefing.md",
       validate: (val) => {
-        if (val && !fs5.existsSync(val)) return "File not found";
+        if (val && !fs4.existsSync(val)) return "File not found";
       }
     });
   }
   if (tui.isCancel(briefingPath)) return;
   if (briefingPath) {
     try {
-      briefingContent = fs5.readFileSync(briefingPath, "utf-8");
+      briefingContent = fs4.readFileSync(briefingPath, "utf-8");
       tui.log.info(`Loaded briefing: ${colors.bold(briefingPath)}`);
     } catch (e) {
       tui.log.error(`Failed to read briefing: ${e}`);
@@ -980,7 +946,7 @@ ${result}
               if (action.path) {
                 try {
                   if (action.type === "create_file") {
-                    fs5.writeFileSync(action.path, action.content || "");
+                    fs4.writeFileSync(action.path, action.content || "");
                     tui.log.success(`\u2705 Created: ${action.path}`);
                     executionResults += `[Action create_file(${action.path})]: Success
 
@@ -992,14 +958,14 @@ ${result}
 
 `;
                     } else {
-                      fs5.writeFileSync(action.path, action.content || "");
+                      fs4.writeFileSync(action.path, action.content || "");
                       tui.log.success(`\u2705 Overwritten: ${action.path}`);
                       executionResults += `[Action modify_file(${action.path})]: Success (Overwrite)
 
 `;
                     }
                   } else if (action.type === "delete_file") {
-                    fs5.unlinkSync(action.path);
+                    fs4.unlinkSync(action.path);
                     tui.log.success(`\u2705 Deleted: ${action.path}`);
                     executionResults += `[Action delete_file(${action.path})]: Success
 
@@ -1119,8 +1085,8 @@ async function callSpecAgentApi(prompt, onChunk, agentId) {
 import { Command as Command2 } from "commander";
 
 // src/core/agents/scan-agent.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path4 from "path";
 var AGENT_TYPE3 = "scan_agent";
 var AGENT_ID3 = process.env.STACKSPOT_SCAN_AGENT_ID || "01KEQ9AHWB550J2244YBH3QATN";
 async function interactiveScanAgent(options = {}) {
@@ -1131,29 +1097,29 @@ async function interactiveScanAgent(options = {}) {
   const projectRoot = process.cwd();
   let outputFile;
   if (options.output) {
-    outputFile = path5.resolve(process.cwd(), options.output);
+    outputFile = path4.resolve(process.cwd(), options.output);
   } else {
-    const outputDir = path5.resolve(projectRoot, "_sharkrc");
-    if (!fs6.existsSync(outputDir)) {
-      const stat = fs6.existsSync(outputDir) ? fs6.statSync(outputDir) : null;
+    const outputDir = path4.resolve(projectRoot, "_sharkrc");
+    if (!fs5.existsSync(outputDir)) {
+      const stat = fs5.existsSync(outputDir) ? fs5.statSync(outputDir) : null;
       if (stat && stat.isFile()) {
         tui.log.warning(`Warning: '_sharkrc' exists as a file. Using '_bmad/project-context' instead to avoid overwrite.`);
-        const fallbackDir = path5.resolve(projectRoot, "_bmad/project-context");
-        if (!fs6.existsSync(fallbackDir)) fs6.mkdirSync(fallbackDir, { recursive: true });
-        outputFile = path5.join(fallbackDir, "project-context.md");
+        const fallbackDir = path4.resolve(projectRoot, "_bmad/project-context");
+        if (!fs5.existsSync(fallbackDir)) fs5.mkdirSync(fallbackDir, { recursive: true });
+        outputFile = path4.join(fallbackDir, "project-context.md");
       } else {
-        fs6.mkdirSync(outputDir, { recursive: true });
-        outputFile = path5.join(outputDir, "project-context.md");
+        fs5.mkdirSync(outputDir, { recursive: true });
+        outputFile = path4.join(outputDir, "project-context.md");
       }
     } else {
-      fs6.mkdirSync(outputDir, { recursive: true });
-      outputFile = path5.join(outputDir, "project-context.md");
+      fs5.mkdirSync(outputDir, { recursive: true });
+      outputFile = path4.join(outputDir, "project-context.md");
     }
   }
   tui.log.info(`Scanning project at: ${colors.bold(projectRoot)}`);
   tui.log.info(`Output targeted at: ${colors.bold(outputFile)}`);
   tui.log.info(`Language: ${colors.bold(language)}`);
-  const configFileRelative = path5.relative(projectRoot, outputFile);
+  const configFileRelative = path4.relative(projectRoot, outputFile);
   const superPrompt = `
 You are the **Scan Agent**, an expert software architect and analyst.
 Your mission is to explore this project's codebase and generate a comprehensive context file that will be used by other AI agents (specifically a Developer Agent) to understand how to work on this project.
@@ -1247,22 +1213,22 @@ ${result}
 
 `;
           } else if (action.type === "create_file" || action.type === "modify_file") {
-            const resolvedActionPath = path5.resolve(action.path || "");
-            const resolvedTargetPath = path5.resolve(targetPath);
+            const resolvedActionPath = path4.resolve(action.path || "");
+            const resolvedTargetPath = path4.resolve(targetPath);
             let isTarget = resolvedActionPath === resolvedTargetPath;
-            if (!isTarget && path5.basename(action.path || "") === "project-context.md") {
-              tui.log.warning(`Agent targeted '${action.path}' but we enforce '${path5.relative(process.cwd(), targetPath)}'. Redirecting write.`);
+            if (!isTarget && path4.basename(action.path || "") === "project-context.md") {
+              tui.log.warning(`Agent targeted '${action.path}' but we enforce '${path4.relative(process.cwd(), targetPath)}'. Redirecting write.`);
               isTarget = true;
               action.path = targetPath;
             }
             if (isTarget) {
               const finalPath = targetPath;
               if (action.type === "create_file") {
-                fs6.writeFileSync(finalPath, action.content || "");
+                fs5.writeFileSync(finalPath, action.content || "");
                 tui.log.success(`\u2705 Generated Context: ${finalPath}`);
                 fileCreated = true;
               } else {
-                fs6.writeFileSync(finalPath, action.content || "");
+                fs5.writeFileSync(finalPath, action.content || "");
                 tui.log.success(`\u2705 Updated Context: ${finalPath}`);
                 fileCreated = true;
               }
@@ -1356,8 +1322,8 @@ var scanCommand = new Command2("scan").description("Analyze the project and gene
 import { Command as Command3 } from "commander";
 
 // src/core/agents/developer-agent.ts
-import fs7 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path5 from "path";
 var AGENT_TYPE4 = "developer_agent";
 var AGENT_ID4 = process.env.STACKSPOT_DEV_AGENT_ID || "01KEQCGJ65YENRA4QBXVN1YFFX";
 async function interactiveDeveloperAgent(options = {}) {
@@ -1369,12 +1335,12 @@ async function interactiveDeveloperAgent(options = {}) {
   }
   const projectRoot = process.cwd();
   let contextContent = "";
-  const defaultContextPath = path6.resolve(projectRoot, "_sharkrc", "project-context.md");
-  const specificContextPath = options.context ? path6.resolve(projectRoot, options.context) : defaultContextPath;
-  if (fs7.existsSync(specificContextPath)) {
+  const defaultContextPath = path5.resolve(projectRoot, "_sharkrc", "project-context.md");
+  const specificContextPath = options.context ? path5.resolve(projectRoot, options.context) : defaultContextPath;
+  if (fs6.existsSync(specificContextPath)) {
     try {
-      contextContent = fs7.readFileSync(specificContextPath, "utf-8");
-      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path6.relative(projectRoot, specificContextPath))}`);
+      contextContent = fs6.readFileSync(specificContextPath, "utf-8");
+      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path5.relative(projectRoot, specificContextPath))}`);
     } catch (e) {
       tui.log.warning(`Failed to read context file: ${e}`);
     }
@@ -1466,11 +1432,11 @@ ${result}
             });
             if (confirm) {
               if (filePath) {
-                const targetPath = path6.resolve(projectRoot, filePath);
-                const dir = path6.dirname(targetPath);
-                if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+                const targetPath = path5.resolve(projectRoot, filePath);
+                const dir = path5.dirname(targetPath);
+                if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
                 if (isCreate) {
-                  fs7.writeFileSync(targetPath, action.content || "");
+                  fs6.writeFileSync(targetPath, action.content || "");
                   tui.log.success(`\u2705 Created: ${filePath}`);
                   executionResults += `[Action create_file(${filePath})]: Success
 
@@ -1540,6 +1506,7 @@ User Reply: ${userReply}`;
     } catch (e) {
       spinner.stop("Error");
       tui.log.error(e.message);
+      FileLogger.log("DEV_AGENT", "Main Loop Error", e);
       keepGoing = false;
     }
   }
@@ -1593,8 +1560,8 @@ var devCommand = new Command3("dev").description("Starts the Shark Developer Age
 import { Command as Command4 } from "commander";
 
 // src/core/agents/qa-agent.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path6 from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 var AGENT_TYPE5 = "qa_agent";
@@ -1658,9 +1625,9 @@ async function runQAAgent(options) {
   }
   let projectContext = "";
   try {
-    const contextPath = path7.join(process.cwd(), "_sharkrc", "project-context.md");
-    if (fs8.existsSync(contextPath)) {
-      projectContext = fs8.readFileSync(contextPath, "utf-8");
+    const contextPath = path6.join(process.cwd(), "_sharkrc", "project-context.md");
+    if (fs7.existsSync(contextPath)) {
+      projectContext = fs7.readFileSync(contextPath, "utf-8");
       tui.log.info(`\u{1F4D8} Context loaded from: _sharkrc/project-context.md`);
     }
   } catch (e) {
@@ -1769,8 +1736,8 @@ ${projectContext}
             break;
           case "create_file":
             if (action.path && action.content) {
-              const fullPath = path7.resolve(process.cwd(), action.path);
-              fs8.writeFileSync(fullPath, action.content);
+              const fullPath = path6.resolve(process.cwd(), action.path);
+              fs7.writeFileSync(fullPath, action.content);
               tui.log.success(`File created: ${action.path}`);
               result = "File created successfully.";
             }