shark-ai 0.0.1

package/dist/bin/shark.js

@@ -0,0 +1,1854 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+import {
+  ConfigManager,
+  colors,
+  configCommand,
+  loginCommand,
+  tokenStorage,
+  tui
+} from "../chunk-B7PNFPUX.js";
+
+// src/core/error/crash-handler.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CrashHandler = class _CrashHandler {
+  static instance;
+  logDir;
+  constructor() {
+    this.logDir = path.join(os.homedir(), ".shark", "logs");
+  }
+  static getInstance() {
+    if (!_CrashHandler.instance) {
+      _CrashHandler.instance = new _CrashHandler();
+    }
+    return _CrashHandler.instance;
+  }
+  init() {
+    process.on("uncaughtException", (error) => this.handleError(error, "Uncaught Exception"));
+    process.on("unhandledRejection", (reason) => this.handleError(reason, "Unhandled Rejection"));
+  }
+  handleError(error, type) {
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const logFile = path.join(this.logDir, `crash-${timestamp}.log`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const stackTrace = error instanceof Error ? error.stack : "No stack trace available";
+      const logContent = `
+[${(/* @__PURE__ */ new Date()).toISOString()}] ${type}
+--------------------------------------------------
+Message: ${errorMessage}
+Stack:
+${stackTrace}
+--------------------------------------------------
+System: ${os.platform()} ${os.release()} ${os.arch()}
+Node: ${process.version}
+`;
+      if (!fs.existsSync(this.logDir)) {
+        fs.mkdirSync(this.logDir, { recursive: true });
+      }
+      fs.writeFileSync(logFile, logContent, "utf-8");
+      console.error("\n");
+      console.error(colors.error("\u{1F4A5}  Whoops! Shark CLI crashed unexpectedly."));
+      console.error(colors.dim(`   Details have been saved to: ${logFile}`));
+      console.error(colors.dim("   Please report this issue so we can fix it."));
+      console.error(colors.error(`   Error: ${errorMessage}`));
+      console.error("\n");
+    } catch (filesysError) {
+      console.error("Fatal Error: Failed to write crash log.", filesysError);
+      console.error("Original Error:", error);
+    } finally {
+      process.exit(1);
+    }
+  }
+};
+var crashHandler = CrashHandler.getInstance();
+
+// src/bin/shark.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+
+// src/core/workflow/workflow-manager.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/core/workflow/shark-workflow.schema.ts
+import { z } from "zod";
+var TechStackEnum = z.enum([
+  "react",
+  "nextjs",
+  "angular",
+  "vue",
+  "node-ts",
+  "python",
+  "dotnet",
+  "java",
+  "unknown"
+]);
+var WorkflowStageEnum = z.enum([
+  "business_analysis",
+  "specification",
+  "architecture",
+  "development",
+  "verification",
+  "deployment"
+]);
+var StageStatusEnum = z.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed",
+  "skipped"
+]);
+var WorkflowSchema = z.object({
+  projectId: z.string().uuid(),
+  projectName: z.string().min(1),
+  techStack: TechStackEnum.default("unknown"),
+  currentStage: WorkflowStageEnum.default("business_analysis"),
+  stageStatus: StageStatusEnum.default("pending"),
+  lastUpdated: z.string().datetime(),
+  // ISO 8601
+  conversationId: z.string().optional(),
+  conversations: z.record(z.string(), z.string()).optional(),
+  // agentType -> conversationId
+  artifacts: z.array(z.string()).default([]),
+  // Extensible metadata bag
+  metadata: z.record(z.unknown()).optional()
+});
+
+// src/core/workflow/workflow-manager.ts
+var WorkflowManager = class _WorkflowManager {
+  static instance;
+  filename = "shark-workflow.json";
+  tmpFilename = ".shark-workflow.tmp";
+  constructor() {
+  }
+  static getInstance() {
+    if (!_WorkflowManager.instance) {
+      _WorkflowManager.instance = new _WorkflowManager();
+    }
+    return _WorkflowManager.instance;
+  }
+  getFilePath() {
+    return path2.join(process.cwd(), this.filename);
+  }
+  getTmpFilePath() {
+    return path2.join(process.cwd(), this.tmpFilename);
+  }
+  async save(state) {
+    const parsed = WorkflowSchema.safeParse(state);
+    if (!parsed.success) {
+      throw new Error(`Invalid workflow state: ${parsed.error.message}`);
+    }
+    const filePath = this.getFilePath();
+    const tmpPath = this.getTmpFilePath();
+    const data = JSON.stringify(parsed.data, null, 2);
+    try {
+      await fs2.writeFile(tmpPath, data, "utf-8");
+      await fs2.rename(tmpPath, filePath);
+    } catch (error) {
+      throw new Error(`Failed to save workflow state atomically: ${error.message}`);
+    }
+  }
+  async load() {
+    const filePath = this.getFilePath();
+    try {
+      try {
+        await fs2.access(filePath);
+      } catch {
+        return null;
+      }
+      const content = await fs2.readFile(filePath, "utf-8");
+      const json = JSON.parse(content);
+      const parsed = WorkflowSchema.safeParse(json);
+      if (parsed.success) {
+        return parsed.data;
+      } else {
+        console.warn(colors.warning(`\u26A0\uFE0F  Corrupted workflow file detected: ${parsed.error.message}`));
+        return null;
+      }
+    } catch (error) {
+      console.warn(colors.warning(`\u26A0\uFE0F  Failed to load workflow state: ${error.message}`));
+      return null;
+    }
+  }
+  // Helper to get current state or default if none exists
+  async getOrInitState() {
+    return await this.load();
+  }
+};
+var workflowManager = WorkflowManager.getInstance();
+
+// src/commands/init.ts
+import { randomUUID } from "crypto";
+var initAction = async () => {
+  tui.intro("Shark Project Initialization");
+  const existingState = await workflowManager.load();
+  if (existingState) {
+    tui.log.info(colors.dim("----------------------------------------"));
+    tui.log.info(`\u{1F988}  ${colors.primary("Welcome back to Shark CLI!")}`);
+    tui.log.message(`   Project: ${colors.white(existingState.projectName)}`);
+    tui.log.message(`   Stage:   ${colors.secondary(existingState.currentStage)}`);
+    tui.log.message(`   Updated: ${colors.dim(new Date(existingState.lastUpdated).toLocaleString())}`);
+    tui.log.info(colors.dim("----------------------------------------"));
+    const action = await tui.select({
+      message: "An existing project was detected. What would you like to do?",
+      options: [
+        { value: "resume", label: "\u{1F680} Resume Work" },
+        { value: "overwrite", label: "\u26A0\uFE0F  Overwrite (Start Fresh)" },
+        { value: "exit", label: "\u274C Exit" }
+      ]
+    });
+    if (tui.isCancel(action) || action === "exit") {
+      tui.outro("See you later! \u{1F44B}");
+      return;
+    }
+    if (action === "resume") {
+      tui.log.success(`Resuming work on ${colors.primary(existingState.projectName)}...`);
+      tui.outro(`To continue, run: "shark agent" (Context loaded)`);
+      return;
+    }
+  }
+  const projectName = await tui.text({
+    message: "What is the name of your project?",
+    placeholder: "e.g. My Awesome App",
+    validate: (value) => {
+      if (!value) return "Project name is required";
+      if (value.trim().length < 2) return "Project name must be at least 2 characters";
+    }
+  });
+  if (tui.isCancel(projectName)) {
+    tui.outro("Initialization cancelled.");
+    return;
+  }
+  const techStackOptions = TechStackEnum.options.map((stack) => ({
+    value: stack,
+    label: stack === "node-ts" ? "Node.js (TypeScript)" : stack === "nextjs" ? "Next.js" : stack.charAt(0).toUpperCase() + stack.slice(1)
+  }));
+  const techStack = await tui.select({
+    message: "Select your technology stack:",
+    options: techStackOptions
+  });
+  if (tui.isCancel(techStack)) {
+    tui.outro("Initialization cancelled.");
+    return;
+  }
+  const spinner = tui.spinner();
+  spinner.start("Initializing project workflow...");
+  try {
+    const newState = {
+      projectId: randomUUID(),
+      projectName,
+      techStack,
+      currentStage: "business_analysis",
+      stageStatus: "pending",
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      artifacts: [],
+      metadata: {
+        initializedBy: "shark-cli",
+        version: "0.0.1"
+      }
+    };
+    await workflowManager.save(newState);
+    spinner.stop("Project workflow created!");
+    tui.log.success(`Project ${colors.primary(projectName)} initialized successfully.`);
+    tui.log.message(`Your Project ID: ${colors.dim(newState.projectId)}`);
+    tui.outro('Ready to start! Run "shark agent" to begin analyzing requirements.');
+  } catch (error) {
+    spinner.stop("Initialization failed.", 1);
+    tui.log.error(error.message);
+    process.exit(1);
+  }
+};
+var initCommand = new Command("init").description("Initialize a new Shark project").action(initAction);
+
+// 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 {
+  /**
+   * Streams agent response using Server-Sent Events.
+   * 
+   * @param url - The SSE endpoint URL
+   * @param requestPayload - The request payload to POST
+   * @param headers - Request headers (including Authorization)
+   * @param callbacks - Event callbacks for chunks, completion, and errors
+   */
+  async streamAgentResponse(url, requestPayload, headers, callbacks = {}) {
+    const { onChunk, onComplete, onError } = callbacks;
+    FileLogger.log("SSE", `Starting Request to ${url}`, {
+      headers,
+      payload: requestPayload
+    });
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          ...headers,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestPayload)
+      });
+      FileLogger.log("SSE", `Response Status: ${response.status} ${response.statusText}`);
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      FileLogger.log("SSE", "Response Headers", responseHeaders);
+      if (!response.ok) {
+        const errorText = await response.text();
+        FileLogger.log("SSE", "Response Error Body", errorText);
+        throw new Error(`SSE request failed: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body is null");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let fullMessage = "";
+      let metadata = {};
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data:")) {
+            const data = line.slice(5).trim();
+            if (data === "[DONE]") {
+              FileLogger.log("SSE", "Stream Complete [DONE]", { fullMessage, metadata });
+              if (onComplete) {
+                onComplete(fullMessage, metadata);
+              }
+              return;
+            }
+            try {
+              const parsed = JSON.parse(data);
+              const chunk = parsed.message || parsed.content || data;
+              fullMessage += chunk;
+              if (parsed.conversation_id) {
+                metadata.conversation_id = parsed.conversation_id;
+              }
+              if (onChunk) {
+                onChunk(chunk);
+              }
+            } catch (parseError) {
+              fullMessage += data;
+              if (onChunk) {
+                onChunk(data);
+              }
+            }
+          }
+        }
+      }
+      FileLogger.log("SSE", "Stream Ended Naturally", { fullMessage, metadata });
+      if (onComplete) {
+        onComplete(fullMessage, metadata);
+      }
+    } catch (error) {
+      FileLogger.log("SSE", "Stream Error", error);
+      if (onError) {
+        onError(error instanceof Error ? error : new Error(String(error)));
+      } else {
+        throw error;
+      }
+    }
+  }
+};
+var sseClient = new SSEClient();
+
+// src/core/agents/agent-response-parser.ts
+import { z as z2 } from "zod";
+var AgentActionSchema = z2.object({
+  type: z2.enum(["create_file", "modify_file", "delete_file", "talk_with_user", "list_files", "read_file", "search_file", "run_command", "use_mcp_tool"]),
+  path: z2.string().nullable().optional(),
+  // Nullable for strict mode combatibility
+  content: z2.string().nullable().optional(),
+  target_content: z2.string().nullable().optional(),
+  command: z2.string().nullable().optional(),
+  tool_name: z2.string().nullable().optional(),
+  tool_args: z2.string().nullable().optional()
+  // JSON string argument
+});
+var AgentCommandSchema = z2.object({
+  command: z2.string(),
+  description: z2.string(),
+  critical: z2.boolean()
+});
+var AgentResponseSchema = z2.object({
+  actions: z2.array(AgentActionSchema),
+  commands: z2.array(AgentCommandSchema).optional(),
+  summary: z2.string().optional(),
+  // Legacy fields handling for smooth transition/fallback
+  message: z2.string().optional(),
+  conversation_id: z2.string().optional()
+});
+function parseAgentResponse(rawResponse) {
+  FileLogger.log("PARSER", "Parsing Agent Response", { rawType: typeof rawResponse });
+  let parsedObj = {};
+  let conversation_id;
+  if (typeof rawResponse === "string") {
+    FileLogger.log("PARSER", "Type String", { length: rawResponse.length });
+    try {
+      parsedObj = extractFirstJson(rawResponse);
+    } catch (e) {
+      FileLogger.log("PARSER", "String Parse Failed", { error: e.message });
+      return {
+        actions: [{
+          type: "talk_with_user",
+          content: rawResponse,
+          path: ""
+        }],
+        message: rawResponse
+      };
+    }
+  } else if (typeof rawResponse === "object" && rawResponse !== null) {
+    const anyResp = rawResponse;
+    conversation_id = anyResp.conversation_id;
+    FileLogger.log("PARSER", "Type Object", {
+      hasContent: !!anyResp.content,
+      hasMessage: !!anyResp.message,
+      messageType: typeof anyResp.message
+    });
+    const stringContent = anyResp.content || anyResp.message;
+    if (stringContent && typeof stringContent === "string") {
+      try {
+        const parsedInside = extractFirstJson(stringContent);
+        if (typeof parsedInside === "object" && parsedInside !== null) {
+          parsedObj = parsedInside;
+          FileLogger.log("PARSER", "Inner JSON Parsed", { keys: Object.keys(parsedObj) });
+        } else {
+          parsedObj = rawResponse;
+          FileLogger.log("PARSER", "Inner JSON was primitive");
+        }
+      } catch (e) {
+        parsedObj = rawResponse;
+        FileLogger.log("PARSER", "Inner JSON Parse Error - treating as raw", { error: e.message });
+      }
+    } else {
+      parsedObj = rawResponse;
+    }
+    if (!parsedObj.actions) {
+      parsedObj = rawResponse;
+    }
+  }
+  if (!parsedObj.actions) {
+    FileLogger.log("PARSER", "No Actions Found - Constructing Default");
+    return {
+      conversation_id,
+      actions: [{
+        type: "talk_with_user",
+        content: parsedObj.message || JSON.stringify(parsedObj),
+        path: ""
+      }],
+      message: parsedObj.message
+    };
+  }
+  const result = {
+    actions: parsedObj.actions,
+    commands: parsedObj.commands || [],
+    summary: parsedObj.summary || "",
+    conversation_id,
+    message: parsedObj.summary || "Agent Action"
+    // Backward compatibility
+  };
+  FileLogger.log("PARSER", "Final Result Constructed", { actionCount: result.actions.length });
+  try {
+    return AgentResponseSchema.parse(result);
+  } catch (e) {
+    FileLogger.log("PARSER", "Schema Validation Failed", { error: e.message });
+    throw e;
+  }
+}
+function extractFirstJson(str) {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    const firstOpen = str.indexOf("{");
+    if (firstOpen === -1) throw e;
+    let balance = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = firstOpen; i < str.length; i++) {
+      const char = str[i];
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (char === "\\") {
+        escape = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (!inString) {
+        if (char === "{") balance++;
+        else if (char === "}") {
+          balance--;
+          if (balance === 0) {
+            const potentialJson = str.substring(firstOpen, i + 1);
+            try {
+              return JSON.parse(potentialJson);
+            } catch (innerE) {
+              throw e;
+            }
+          }
+        }
+      }
+    }
+    throw e;
+  }
+}
+
+// src/core/workflow/conversation-manager.ts
+var ConversationManager = class _ConversationManager {
+  static instance;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_ConversationManager.instance) {
+      _ConversationManager.instance = new _ConversationManager();
+    }
+    return _ConversationManager.instance;
+  }
+  /**
+   * Saves a conversation ID for a specific agent type.
+   * 
+   * @param agentType - The type of agent (e.g., 'business_analyst', 'architect')
+   * @param conversationId - The conversation ID from the agent response
+   */
+  async saveConversationId(agentType, conversationId) {
+    const state = await workflowManager.load();
+    if (!state) {
+      throw new Error('No workflow state found. Please run "shark init" first.');
+    }
+    if (!state.conversations) {
+      state.conversations = {};
+    }
+    state.conversations[agentType] = conversationId;
+    await workflowManager.save(state);
+  }
+  /**
+   * Retrieves the conversation ID for a specific agent type.
+   * 
+   * @param agentType - The type of agent
+   * @returns The conversation ID, or undefined if none exists
+   */
+  async getConversationId(agentType) {
+    const state = await workflowManager.load();
+    if (!state || !state.conversations) {
+      return void 0;
+    }
+    return state.conversations[agentType];
+  }
+  /**
+   * Clears the conversation ID for a specific agent type.
+   * 
+   * @param agentType - The type of agent
+   */
+  async clearConversationId(agentType) {
+    const state = await workflowManager.load();
+    if (!state || !state.conversations) {
+      return;
+    }
+    delete state.conversations[agentType];
+    await workflowManager.save(state);
+  }
+  /**
+   * Clears all conversation IDs.
+   * Useful when transitioning to a new project or resetting state.
+   */
+  async clearAllConversations() {
+    const state = await workflowManager.load();
+    if (!state) {
+      return;
+    }
+    state.conversations = {};
+    await workflowManager.save(state);
+  }
+};
+var conversationManager = ConversationManager.getInstance();
+
+// src/core/auth/get-active-realm.ts
+async function getActiveRealm() {
+  const configManager = ConfigManager.getInstance();
+  const config = configManager.getConfig();
+  const realm = config.activeRealm;
+  if (!realm) {
+    throw new Error(
+      'No active authentication found.\nPlease run "shark login" first to authenticate.'
+    );
+  }
+  return realm;
+}
+
+// src/core/agents/business-analyst-agent.ts
+var AGENT_TYPE = "business_analyst";
+var AGENT_ID = process.env.STACKSPOT_BA_AGENT_ID || "01KEJ95G304TNNAKGH5XNEEBVD";
+async function runBusinessAnalystAgent(prompt, options = {}) {
+  const { agentId, onChunk, onComplete } = options;
+  const realm = await getActiveRealm();
+  const token = await tokenStorage.getToken(realm);
+  if (!token) {
+    throw new Error(`No authentication token found for realm '${realm}'. Please run 'shark login'.`);
+  }
+  const existingConversationId = await conversationManager.getConversationId(AGENT_TYPE);
+  const requestPayload = {
+    user_prompt: prompt,
+    streaming: true,
+    stackspot_knowledge: false,
+    // Use agent's configured KS instead
+    return_ks_in_response: true,
+    deep_search_ks: false,
+    conversation_id: existingConversationId
+  };
+  const finalAgentId = agentId || AGENT_ID;
+  const agentUrl = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${finalAgentId}/chat`;
+  const headers = {
+    "Authorization": `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  let fullMessage = "";
+  let rawResponse = {};
+  await sseClient.streamAgentResponse(
+    agentUrl,
+    requestPayload,
+    headers,
+    {
+      onChunk: (chunk) => {
+        fullMessage += chunk;
+        if (onChunk) {
+          onChunk(chunk);
+        }
+      },
+      onComplete: async (message) => {
+        rawResponse = {
+          message: message || fullMessage,
+          conversation_id: existingConversationId
+          // Will be updated if new one provided
+        };
+      },
+      onError: (error) => {
+        throw error;
+      }
+    }
+  );
+  const parsedResponse = parseAgentResponse(rawResponse);
+  if (parsedResponse.conversation_id) {
+    await conversationManager.saveConversationId(AGENT_TYPE, parsedResponse.conversation_id);
+  }
+  if (onComplete) {
+    onComplete(parsedResponse);
+  }
+  return parsedResponse;
+}
+async function interactiveBusinessAnalyst() {
+  tui.intro("\u{1F3AF} Business Analyst Agent");
+  const prompt = await tui.text({
+    message: "Describe your project idea",
+    placeholder: "E.g., I want to build a task management app for teams...",
+    validate: (value) => {
+      if (!value || value.length < 10) return "Please provide a detailed description (at least 10 characters)";
+    }
+  });
+  if (tui.isCancel(prompt)) {
+    tui.outro("Cancelled");
+    return;
+  }
+  const spinner = tui.spinner();
+  spinner.start("\u{1F4AC} Business Analyst is thinking...");
+  let responseText = "";
+  try {
+    await runBusinessAnalystAgent(prompt, {
+      onChunk: (chunk) => {
+        responseText += chunk;
+        try {
+          if (responseText.trim().startsWith("{")) {
+            spinner.message(colors.dim("Receiving structured data..."));
+          } else {
+            spinner.message(colors.dim("Thinking..."));
+          }
+        } catch (e) {
+        }
+      },
+      onComplete: async (response) => {
+        spinner.stop("Response received");
+        if (response.summary) {
+          tui.log.info(colors.italic(response.summary));
+        }
+        if (response.actions && response.actions.length > 0) {
+          for (const action of response.actions) {
+            if (action.type === "talk_with_user") {
+              tui.log.info(colors.green("\u{1F916} BA Agent:"));
+              console.log(action.content);
+            } else {
+              tui.log.warning(`
+\u{1F916} Agent wants to ${action.type}: ${colors.bold(action.path || "unknown")}`);
+              if (action.content) {
+                console.log(colors.dim("--- Content Preview ---"));
+                console.log(action.content.substring(0, 300) + (action.content.length > 300 ? "..." : ""));
+                console.log(colors.dim("-----------------------"));
+              }
+              const confirm = await tui.confirm({
+                message: `Allow agent to ${action.type} '${action.path}'?`,
+                active: "Yes",
+                inactive: "No"
+              });
+              if (confirm) {
+                tui.log.success(`\u2705 Action executed: ${action.path} created.`);
+              } else {
+                tui.log.error("\u274C Action denied.");
+              }
+            }
+          }
+        }
+        if (response.tokens) {
+          tui.log.info(`Tokens used: ${response.tokens.output || 0}`);
+        }
+      }
+    });
+    tui.outro("Session complete");
+  } catch (error) {
+    spinner.stop("\u274C Error", 1);
+    tui.log.error(error.message);
+    throw error;
+  }
+}
+
+// src/core/agents/specification-agent.ts
+import fs5 from "fs";
+
+// src/core/agents/agent-tools.ts
+import fs4 from "fs";
+import path4 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 });
+    return items.map((item) => {
+      return `${item.isDirectory() ? "[DIR]" : "[FILE]"} ${item.name}`;
+    }).join("\n");
+  } catch (e) {
+    return `Error listing files: ${e.message}`;
+  }
+}
+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);
+    if (stats.size > 100 * 1024) return `Error: File too large to read (${stats.size} bytes). Limit is 100KB.`;
+    return fs4.readFileSync(fullPath, "utf-8");
+  } catch (e) {
+    return `Error reading file: ${e.message}`;
+  }
+}
+function handleSearchFile(pattern) {
+  try {
+    const entries = fg.sync(pattern, { dot: true });
+    if (entries.length === 0) return "No files found matching pattern.";
+    return entries.slice(0, 50).join("\n");
+  } catch (e) {
+    return `Error searching files: ${e.message}`;
+  }
+}
+function startSmartReplace(filePath, newContent, targetContent, tui2) {
+  if (!fs4.existsSync(filePath)) {
+    tui2.log.error(`\u274C File not found for modification: ${filePath}`);
+    return false;
+  }
+  const currentFileContent = fs4.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 ---"));
+    console.log(targetContent.substring(0, 200) + "...");
+    return false;
+  }
+  const occurrences = currentFileContent.split(targetContent).length - 1;
+  if (occurrences > 1) {
+    tui2.log.error(`\u274C Ambiguous target: Found ${occurrences} occurrences in ${filePath}. Modification aborted.`);
+    return false;
+  }
+  const updatedContent = currentFileContent.replace(targetContent, newContent);
+  fs4.writeFileSync(filePath, updatedContent);
+  tui2.log.success(`\u2705 Smart Replace Applied: ${filePath}`);
+  return true;
+}
+async function handleRunCommand(command) {
+  const { spawn } = await import("child_process");
+  try {
+    tui.log.info(`\u{1F4BB} Executing: ${colors.dim(command)}`);
+    return new Promise((resolve) => {
+      const child = spawn(command, {
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        cwd: process.cwd()
+      });
+      let stdout = "";
+      let stderr = "";
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve(`Error: Command timed out after 5 minutes.
+Output so far:
+${stdout}
+${stderr}`);
+      }, 5 * 60 * 1e3);
+      child.stdout.on("data", (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolve(stdout.trim() || "Command executed successfully (no output).");
+        } else {
+          resolve(`Command failed with exit code ${code}.
+STDERR:
+${stderr}
+STDOUT:
+${stdout}`);
+        }
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve(`Error executing command: ${err.message}`);
+      });
+    });
+  } catch (e) {
+    return `Error launching command: ${e.message}`;
+  }
+}
+
+// src/core/agents/specification-agent.ts
+var AGENT_TYPE2 = "specification_agent";
+var AGENT_ID2 = process.env.STACKSPOT_SPEC_AGENT_ID || "01KEPXTX37FTB4N672TZST4SGP";
+async function interactiveSpecificationAgent(options = {}) {
+  FileLogger.init();
+  tui.intro("\u{1F3D7}\uFE0F  Specification Agent");
+  let briefingContent = "";
+  let briefingPath = options.briefingPath;
+  if (!briefingPath) {
+    const files = fs5.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 (tui.isCancel(briefingPath)) return;
+  if (briefingPath) {
+    try {
+      briefingContent = fs5.readFileSync(briefingPath, "utf-8");
+      tui.log.info(`Loaded briefing: ${colors.bold(briefingPath)}`);
+    } catch (e) {
+      tui.log.error(`Failed to read briefing: ${e}`);
+      return;
+    }
+  } else {
+    tui.log.info("Skipping briefing file. Starting fresh or exploring existing project.");
+  }
+  const initialPrompt = briefingContent ? `
+Tenho o seguinte Documento de Briefing de Neg\xF3cio. 
+Por favor, analise-o e inicie o processo de defini\xE7\xE3o da Especifica\xE7\xE3o T\xE9cnica.
+
+---
+${briefingContent}
+---
+    `.trim() : "Gostaria de ajuda com uma especifica\xE7\xE3o t\xE9cnica ou explorar este projeto.";
+  await runSpecLoop(initialPrompt, options.agentId);
+}
+async function runSpecLoop(initialMessage, overrideAgentId) {
+  let nextPrompt = initialMessage;
+  let keepGoing = true;
+  while (keepGoing) {
+    const spinner = tui.spinner();
+    spinner.start("\u{1F3D7}\uFE0F  Specification Agent is thinking...");
+    let responseText = "";
+    let lastResponse = null;
+    try {
+      lastResponse = await callSpecAgentApi(nextPrompt, (chunk) => {
+        responseText += chunk;
+        try {
+          if (responseText.trim().startsWith("{")) {
+            spinner.message(colors.dim("Receiving structured data..."));
+          } else {
+            spinner.message(colors.dim("Thinking..."));
+          }
+        } catch (e) {
+        }
+      }, overrideAgentId);
+      spinner.stop("Response received");
+      if (lastResponse && lastResponse.actions) {
+        let executionResults = "";
+        let waitingForUser = false;
+        for (const action of lastResponse.actions) {
+          if (action.type === "talk_with_user") {
+            tui.log.info(colors.primary("\u{1F916} Architect:"));
+            console.log(action.content);
+            waitingForUser = true;
+          } else if (action.type === "list_files") {
+            tui.log.info(`\u{1F4C2} List files in: ${colors.bold(action.path || ".")}`);
+            const result = handleListFiles(action.path || ".");
+            executionResults += `[Action list_files(${action.path}) Result]:
+${result}
+
+`;
+            tui.log.info(colors.dim(`Files listed.`));
+          } else if (action.type === "read_file") {
+            tui.log.info(`\u{1F4D6} Read file: ${colors.bold(action.path || "")}`);
+            const result = handleReadFile(action.path || "");
+            executionResults += `[Action read_file(${action.path}) Result]:
+${result}
+
+`;
+            tui.log.info(colors.dim(`File read.`));
+          } else if (action.type === "search_file") {
+            tui.log.info(`\u{1F50D} Search file: ${colors.bold(action.path || "")}`);
+            const result = handleSearchFile(action.path || "");
+            executionResults += `[Action search_file(${action.path}) Result]:
+${result}
+
+`;
+            tui.log.info(colors.dim(`Files found.`));
+          } else if (["create_file", "modify_file", "delete_file"].includes(action.type)) {
+            tui.log.warning(`
+\u{1F916} Agent wants to ${action.type}: ${colors.bold(action.path || "unknown")}`);
+            if (action.content) {
+              console.log(colors.dim("--- Content Preview ---"));
+              console.log(action.content.substring(0, 300) + "...");
+              console.log(colors.dim("-----------------------"));
+            }
+            const confirm = await tui.confirm({
+              message: `Approve ${action.type}?`,
+              active: "Yes",
+              inactive: "No"
+            });
+            if (confirm) {
+              if (action.path) {
+                try {
+                  if (action.type === "create_file") {
+                    fs5.writeFileSync(action.path, action.content || "");
+                    tui.log.success(`\u2705 Created: ${action.path}`);
+                    executionResults += `[Action create_file(${action.path})]: Success
+
+`;
+                  } else if (action.type === "modify_file") {
+                    if (action.target_content) {
+                      const success = startSmartReplace(action.path, action.content || "", action.target_content, tui);
+                      executionResults += `[Action modify_file(${action.path})]: ${success ? "Success" : "Failed"}
+
+`;
+                    } else {
+                      fs5.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);
+                    tui.log.success(`\u2705 Deleted: ${action.path}`);
+                    executionResults += `[Action delete_file(${action.path})]: Success
+
+`;
+                  }
+                } catch (e) {
+                  tui.log.error(`\u274C Failed: ${e.message}`);
+                  executionResults += `[Action ${action.type}(${action.path})]: Error: ${e.message}
+
+`;
+                }
+              }
+            } else {
+              tui.log.error("\u274C Action denied.");
+              executionResults += `[Action ${action.type}]: User Denied
+
+`;
+            }
+          }
+        }
+        if (executionResults) {
+          if (waitingForUser) {
+            const userReply = await tui.text({
+              message: "Your answer",
+              placeholder: "Type your answer..."
+            });
+            if (tui.isCancel(userReply)) {
+              keepGoing = false;
+              return;
+            }
+            nextPrompt = `${executionResults}
+
+User Reply: ${userReply}`;
+            tui.log.info(colors.dim("Auto-replying with tool results..."));
+          } else {
+            nextPrompt = executionResults;
+            FileLogger.log("SYSTEM", "Auto-replying with Tool Results", { length: executionResults.length });
+            tui.log.info(colors.dim("Auto-replying with tool results..."));
+          }
+        } else if (waitingForUser) {
+          const userReply = await tui.text({
+            message: "Your answer",
+            placeholder: "Type your answer..."
+          });
+          if (tui.isCancel(userReply)) {
+            keepGoing = false;
+            return;
+          }
+          nextPrompt = userReply;
+        } else {
+          tui.log.warning("No actions taken.");
+          keepGoing = false;
+        }
+      } else {
+        tui.log.warning("No actions received from agent.");
+        keepGoing = false;
+      }
+    } catch (error) {
+      spinner.stop("Error");
+      tui.log.error(error.message);
+      keepGoing = false;
+    }
+  }
+}
+async function callSpecAgentApi(prompt, onChunk, agentId) {
+  const realm = await getActiveRealm();
+  const token = await tokenStorage.getToken(realm);
+  if (!token) throw new Error("Not logged in");
+  const conversationId = await conversationManager.getConversationId(AGENT_TYPE2);
+  const payload = {
+    user_prompt: prompt,
+    streaming: true,
+    stackspot_knowledge: false,
+    return_ks_in_response: true,
+    use_conversation: true,
+    conversation_id: conversationId
+  };
+  const finalId = agentId || AGENT_ID2;
+  const url = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${finalId}/chat`;
+  let fullMsg = "";
+  let raw = {};
+  FileLogger.log("AGENT", "Calling Agent API", {
+    agentId: finalId,
+    conversationId,
+    prompt: prompt.substring(0, 500)
+    // Log summary of prompt
+  });
+  await sseClient.streamAgentResponse(url, payload, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" }, {
+    onChunk: (c) => {
+      fullMsg += c;
+      onChunk(c);
+    },
+    onComplete: (msg, metadata) => {
+      const returnedId = metadata?.conversation_id;
+      FileLogger.log("AGENT", "Response Complete", {
+        conversationId,
+        returnedId,
+        messageLength: msg?.length
+      });
+      raw = {
+        message: msg || fullMsg,
+        conversation_id: returnedId || conversationId
+      };
+    },
+    onError: (e) => {
+      throw e;
+    }
+  });
+  const parsed = parseAgentResponse(raw);
+  if (parsed.conversation_id) {
+    await conversationManager.saveConversationId(AGENT_TYPE2, parsed.conversation_id);
+  }
+  return parsed;
+}
+
+// src/commands/scan.ts
+import { Command as Command2 } from "commander";
+
+// src/core/agents/scan-agent.ts
+import fs6 from "fs";
+import path5 from "path";
+var AGENT_TYPE3 = "scan_agent";
+var AGENT_ID3 = process.env.STACKSPOT_SCAN_AGENT_ID || "01KEQ9AHWB550J2244YBH3QATN";
+async function interactiveScanAgent(options = {}) {
+  FileLogger.init();
+  tui.intro("\u{1F575}\uFE0F\u200D\u2642\uFE0F  Scan Agent");
+  const config = ConfigManager.getInstance().getConfig();
+  const language = config.language || "English";
+  const projectRoot = process.cwd();
+  let outputFile;
+  if (options.output) {
+    outputFile = path5.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;
+      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");
+      } else {
+        fs6.mkdirSync(outputDir, { recursive: true });
+        outputFile = path5.join(outputDir, "project-context.md");
+      }
+    } else {
+      fs6.mkdirSync(outputDir, { recursive: true });
+      outputFile = path5.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 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.
+
+**Goal**: Create a markdown file at: \`${configFileRelative}\`.
+
+**LANGUAGE INSTRUCTION**:
+You MUST write the content of the \`project-context.md\` file in **${language}**.
+Also, strictly interact with tools using the appropriate payload.
+
+**Instructions**:
+1.  **Analyze Structure**: Use \`list_files\` to understand the root directory and key subdirectories (src, tools, config, etc.).
+2.  **Identify Tech Stack**: Use \`read_file\` or \`search_file\` on key manifests (package.json, pom.xml, go.mod, Dockerfile, etc.) to determine languages, frameworks, and versions.
+3.  **Map Architecture**: Infer the architectural pattern (Monolith? Microservices? Clean Architecture?) based on folder structure and key files.
+4.  **Document Key Paths**: Identify where source code, tests, and configs live.
+
+**Output Format** (Markdown):
+The final action MUST be \`create_file\` (or \`modify_file\`) for the target file with the following structure:
+
+# Project Context
+
+## Overview
+[Brief description of what this project seems to be]
+
+## Tech Stack
+- **Language**: [e.g. TypeScript]
+- **Framework**: [e.g. React, Express, NestJS]
+- **Build Tool**: [e.g. Vite, Webpack]
+- **Database**: [e.g. PostgreSQL, Prisma] (if detected)
+
+## Architecture
+[Description of the folder structure and architectural patterns detected]
+
+## Key Locations
+- **Source**: [path/to/src]
+- **Tests**: [path/to/tests]
+- **Config**: [path/to/config]
+
+## Commands
+[List of discovered npm scripts or makefile commands for dev, build, test]
+
+---
+
+**Rules**:
+- Do NOT guess. If you are unsure, check the file.
+- Be concise.
+- Focus on FACTS that a Developer Agent needs to know to write code correcty.
+- Start by listing the root directory.
+`.trim();
+  await runScanLoop(superPrompt, outputFile);
+}
+async function runScanLoop(initialPrompt, targetPath) {
+  let nextPrompt = initialPrompt;
+  let keepGoing = true;
+  let stepCount = 0;
+  const MAX_STEPS = 15;
+  while (keepGoing && stepCount < MAX_STEPS) {
+    stepCount++;
+    const spinner = tui.spinner();
+    spinner.start(`\u{1F575}\uFE0F\u200D\u2642\uFE0F  Scan Agent analyzing (Step ${stepCount}/${MAX_STEPS})...`);
+    let responseText = "";
+    let lastResponse = null;
+    try {
+      lastResponse = await callScanAgentApi(nextPrompt, (chunk) => {
+        responseText += chunk;
+      });
+      spinner.stop("Step complete");
+      if (lastResponse && lastResponse.actions) {
+        let executionResults = "";
+        let fileCreated = false;
+        for (const action of lastResponse.actions) {
+          if (action.type === "list_files") {
+            tui.log.info(`\u{1F4C2} Scanning dir: ${colors.bold(action.path || ".")}`);
+            const result = handleListFiles(action.path || ".");
+            executionResults += `[Action list_files(${action.path}) Result]:
+${result}
+
+`;
+          } else if (action.type === "read_file") {
+            tui.log.info(`\u{1F4D6} Reading file: ${colors.bold(action.path || "")}`);
+            const result = handleReadFile(action.path || "");
+            executionResults += `[Action read_file(${action.path}) Result]:
+${result}
+
+`;
+          } else if (action.type === "search_file") {
+            tui.log.info(`\u{1F50D} Searching: ${colors.bold(action.path || "")}`);
+            const result = handleSearchFile(action.path || "");
+            executionResults += `[Action search_file(${action.path}) Result]:
+${result}
+
+`;
+          } else if (action.type === "create_file" || action.type === "modify_file") {
+            const resolvedActionPath = path5.resolve(action.path || "");
+            const resolvedTargetPath = path5.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.`);
+              isTarget = true;
+              action.path = targetPath;
+            }
+            if (isTarget) {
+              const finalPath = targetPath;
+              if (action.type === "create_file") {
+                fs6.writeFileSync(finalPath, action.content || "");
+                tui.log.success(`\u2705 Generated Context: ${finalPath}`);
+                fileCreated = true;
+              } else {
+                fs6.writeFileSync(finalPath, action.content || "");
+                tui.log.success(`\u2705 Updated Context: ${finalPath}`);
+                fileCreated = true;
+              }
+              executionResults += `[Action ${action.type}]: Success. Task Completed.
+`;
+            } else {
+              tui.log.warning(`Agent wants to write to unexpected file: ${action.path}`);
+              executionResults += `[Action ${action.type}]: Skipped (Scan Agent only writes context file)
+`;
+            }
+          } else if (action.type === "talk_with_user") {
+            tui.log.info(colors.primary("\u{1F916} Scan Agent asks:"));
+            console.log(action.content);
+            const reply = await tui.text({ message: "Agent needs input:", placeholder: "Reply..." });
+            executionResults += `[User Reply]: ${reply}
+`;
+          }
+        }
+        if (fileCreated) {
+          tui.log.success("\u2728 Scan completed successfully!");
+          keepGoing = false;
+        } else {
+          nextPrompt = executionResults;
+          FileLogger.log("SCAN", "Auto-replying with results", { length: executionResults.length });
+        }
+      } else {
+        if (stepCount > 1) {
+          tui.log.warning("Scan Agent stopped without actions.");
+          keepGoing = false;
+        } else {
+        }
+      }
+    } catch (error) {
+      spinner.stop("Error");
+      tui.log.error(error.message);
+      keepGoing = false;
+    }
+  }
+}
+async function callScanAgentApi(prompt, onChunk) {
+  const realm = await getActiveRealm();
+  const token = await tokenStorage.getToken(realm);
+  if (!token) throw new Error("Not logged in");
+  let conversationId = await conversationManager.getConversationId(AGENT_TYPE3);
+  const payload = {
+    user_prompt: prompt,
+    streaming: true,
+    stackspot_knowledge: false,
+    return_ks_in_response: true,
+    use_conversation: true,
+    conversation_id: conversationId
+  };
+  const url = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${AGENT_ID3}/chat`;
+  let fullMsg = "";
+  let raw = {};
+  FileLogger.log("SCAN", "Calling API", { promptLength: prompt.length });
+  await sseClient.streamAgentResponse(url, payload, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" }, {
+    onChunk: (c) => {
+      fullMsg += c;
+      onChunk(c);
+    },
+    onComplete: (msg, metadata) => {
+      const returnedId = metadata?.conversation_id;
+      raw = {
+        message: msg || fullMsg,
+        conversation_id: returnedId || conversationId
+      };
+    },
+    onError: (e) => {
+      throw e;
+    }
+  });
+  const parsed = parseAgentResponse(raw);
+  if (parsed.conversation_id) {
+    await conversationManager.saveConversationId(AGENT_TYPE3, parsed.conversation_id);
+  }
+  return parsed;
+}
+
+// src/commands/scan.ts
+var scanCommand = new Command2("scan").description("Analyze the project and generate context documentation").option("-o, --output <path>", "Output file path (default: _bmad/project-context/project-context.md)").option("--depth <level>", "Scan depth (quick, deep, exhaustive)", "quick").action(async (options) => {
+  try {
+    await interactiveScanAgent(options);
+  } catch (error) {
+    console.error("Error during scan:", error.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/dev.ts
+import { Command as Command3 } from "commander";
+
+// src/core/agents/developer-agent.ts
+import fs7 from "fs";
+import path6 from "path";
+var AGENT_TYPE4 = "developer_agent";
+var AGENT_ID4 = process.env.STACKSPOT_DEV_AGENT_ID || "01KEQCGJ65YENRA4QBXVN1YFFX";
+async function interactiveDeveloperAgent(options = {}) {
+  FileLogger.init();
+  tui.intro("\u{1F988} Shark Dev Agent");
+  if (AGENT_ID4 === "PENDING_CONFIGURATION") {
+    tui.log.error("\u274C STACKSPOT_DEV_AGENT_ID not configured in .env");
+    return;
+  }
+  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)) {
+    try {
+      contextContent = fs7.readFileSync(specificContextPath, "utf-8");
+      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path6.relative(projectRoot, specificContextPath))}`);
+    } catch (e) {
+      tui.log.warning(`Failed to read context file: ${e}`);
+    }
+  } else {
+    tui.log.warning(`\u26A0\uFE0F No context file found. Agent will run without pre-loaded context.`);
+  }
+  let nextPrompt = options.task || "I'm ready to help. What's the task?";
+  if (contextContent) {
+    nextPrompt += `
+
+--- PROJECT CONTEXT ---
+${contextContent}
+-----------------------`;
+  }
+  let keepGoing = true;
+  const spinner = tui.spinner();
+  while (keepGoing) {
+    try {
+      spinner.start("Waiting for Agent...");
+      let lastResponse = null;
+      await callDevAgentApi(nextPrompt, (chunk) => {
+        if (!lastResponse) {
+        }
+      }).then((resp) => {
+        lastResponse = resp;
+      });
+      spinner.stop("Response received");
+      if (lastResponse && lastResponse.actions) {
+        const response = lastResponse;
+        let executionResults = "";
+        let waitingForUser = false;
+        for (const action of response.actions) {
+          if (action.type === "talk_with_user") {
+            tui.log.info(colors.primary("\u{1F916} Shark Dev:"));
+            console.log(action.content);
+            waitingForUser = true;
+          } else if (action.type === "list_files") {
+            tui.log.info(`\u{1F4C2} Scanning dir: ${colors.dim(action.path || ".")}`);
+            const result = handleListFiles(action.path || ".");
+            executionResults += `[Action list_files(${action.path}) Result]:
+${result}
+
+`;
+          } else if (action.type === "read_file") {
+            tui.log.info(`\u{1F4D6} Reading: ${colors.dim(action.path || "")}`);
+            const result = handleReadFile(action.path || "");
+            executionResults += `[Action read_file(${action.path}) Result]:
+${result}
+
+`;
+          } else if (action.type === "search_file") {
+            tui.log.info(`\u{1F50D} Searching: ${colors.dim(action.path || "")}`);
+            const result = handleSearchFile(action.path || "");
+            executionResults += `[Action search_file(${action.path}) Result]:
+${result}
+
+`;
+          } else if (action.type === "run_command") {
+            const cmd = action.command || "";
+            tui.log.info(`\u{1F4BB} Executing: ${colors.dim(cmd)}`);
+            const confirm = await tui.confirm({
+              message: `Execute command: ${cmd}?`,
+              active: "Yes",
+              inactive: "No"
+            });
+            if (confirm) {
+              const result = await handleRunCommand(cmd);
+              executionResults += `[Action run_command(${cmd}) Result]:
+${result}
+
+`;
+            } else {
+              executionResults += `[Action run_command]: User blocked execution.
+
+`;
+            }
+          } else if (["create_file", "modify_file"].includes(action.type)) {
+            const isCreate = action.type === "create_file";
+            const filePath = action.path || "";
+            tui.log.warning(`
+\u{1F916} Agent wants to ${isCreate ? "CREATE" : "MODIFY"}: ${colors.bold(filePath)}`);
+            if (action.content) {
+              console.log(colors.dim("--- Content ---\n") + action.content.substring(0, 200) + "...\n" + colors.dim("---------------"));
+            }
+            const confirm = await tui.confirm({
+              message: `Approve changes to ${filePath}?`,
+              active: "Yes",
+              inactive: "No"
+            });
+            if (confirm) {
+              if (filePath) {
+                const targetPath = path6.resolve(projectRoot, filePath);
+                const dir = path6.dirname(targetPath);
+                if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+                if (isCreate) {
+                  fs7.writeFileSync(targetPath, action.content || "");
+                  tui.log.success(`\u2705 Created: ${filePath}`);
+                  executionResults += `[Action create_file(${filePath})]: Success
+
+`;
+                } else {
+                  if (action.target_content) {
+                    const success = startSmartReplace(filePath, action.content || "", action.target_content, tui);
+                    executionResults += `[Action modify_file(${filePath})]: ${success ? "Success" : "Failed"}
+
+`;
+                  } else {
+                    tui.log.error("\u274C Missing target_content for modification.");
+                    executionResults += `[Action modify_file]: Failed. Missing target_content.
+
+`;
+                  }
+                }
+              }
+            } else {
+              tui.log.error("\u274C Denied.");
+              executionResults += `[Action ${action.type}]: User Denied.
+
+`;
+            }
+          }
+        }
+        if (executionResults) {
+          if (waitingForUser) {
+            const userReply = await tui.text({ message: "Your answer:" });
+            if (tui.isCancel(userReply)) {
+              keepGoing = false;
+              break;
+            }
+            nextPrompt = `${executionResults}
+
+User Reply: ${userReply}`;
+          } else {
+            nextPrompt = executionResults;
+            tui.log.info(colors.dim("Sending tool results to agent..."));
+          }
+        } else if (waitingForUser) {
+          const userReply = await tui.text({ message: "Your answer:" });
+          if (tui.isCancel(userReply)) {
+            keepGoing = false;
+            break;
+          }
+          nextPrompt = userReply;
+        } else {
+          if (response.message) {
+            tui.log.info(colors.primary("\u{1F916} Shark Dev:"));
+            console.log(response.message);
+            const userReply = await tui.text({ message: "Your answer:" });
+            if (tui.isCancel(userReply)) {
+              keepGoing = false;
+            } else {
+              nextPrompt = userReply;
+            }
+          } else {
+            tui.log.warning("Agent took no actions.");
+            keepGoing = false;
+          }
+        }
+      } else {
+        tui.log.warning("Invalid response from agent.");
+        keepGoing = false;
+      }
+    } catch (e) {
+      spinner.stop("Error");
+      tui.log.error(e.message);
+      keepGoing = false;
+    }
+  }
+  tui.outro("\u{1F44B} Shark Dev Session Ended");
+}
+async function callDevAgentApi(prompt, onChunk) {
+  const realm = await getActiveRealm();
+  const token = await tokenStorage.getToken(realm);
+  if (!token) throw new Error("Not logged in. Run shark login.");
+  const conversationId = await conversationManager.getConversationId(AGENT_TYPE4);
+  const payload = {
+    user_prompt: prompt,
+    streaming: true,
+    use_conversation: true,
+    conversation_id: conversationId,
+    stackspot_knowledge: false
+    // Dev Agent focuses on project context
+  };
+  const url = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${AGENT_ID4}/chat`;
+  let fullMsg = "";
+  let raw = {};
+  await sseClient.streamAgentResponse(url, payload, { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" }, {
+    onChunk: (c) => {
+      fullMsg += c;
+      onChunk(c);
+    },
+    onComplete: (msg, metadata) => {
+      const returnedId = metadata?.conversation_id;
+      raw = {
+        message: msg || fullMsg,
+        conversation_id: returnedId || conversationId
+      };
+    },
+    onError: (e) => {
+      throw e;
+    }
+  });
+  const parsed = parseAgentResponse(raw);
+  if (parsed.conversation_id) {
+    await conversationManager.saveConversationId(AGENT_TYPE4, parsed.conversation_id);
+  }
+  return parsed;
+}
+
+// src/commands/dev.ts
+var devCommand = new Command3("dev").description("Starts the Shark Developer Agent (Shark Dev)").option("-t, --task <type>", "Initial task description").option("-c, --context <path>", "Path to custom context file").action(async (options) => {
+  await interactiveDeveloperAgent(options);
+});
+
+// src/commands/qa.ts
+import { Command as Command4 } from "commander";
+
+// src/core/agents/qa-agent.ts
+import fs8 from "fs";
+import path7 from "path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var AGENT_TYPE5 = "qa_agent";
+var AGENT_ID5 = process.env.STACKSPOT_QA_AGENT_ID || "01KEQFJZ3Q3JER11NH22HEZX9X";
+var ChromeDevToolsClient = class {
+  client = null;
+  transport = null;
+  async connect() {
+    if (this.client) return;
+    try {
+      this.transport = new StdioClientTransport({
+        command: "npx",
+        args: ["-y", "chrome-devtools-mcp@latest"]
+      });
+      this.client = new Client({
+        name: "shark-qa-client",
+        version: "1.0.0"
+      }, {
+        capabilities: {}
+      });
+      await this.client.connect(this.transport);
+      tui.log.success("\u{1F50C} Connected to Chrome DevTools MCP");
+    } catch (e) {
+      tui.log.error(`Failed to connect to Chrome MCP: ${e.message}`);
+      throw e;
+    }
+  }
+  async callTool(name, args) {
+    if (!this.client) await this.connect();
+    try {
+      const result = await this.client.callTool({
+        name,
+        arguments: args
+      });
+      return result;
+    } catch (e) {
+      return { isError: true, content: [{ type: "text", text: `MCP Error: ${e.message}` }] };
+    }
+  }
+  async close() {
+    if (this.transport) {
+      await this.transport.close();
+    }
+  }
+};
+var mcpClient = new ChromeDevToolsClient();
+async function runQAAgent(options) {
+  if (!AGENT_ID5) {
+    tui.log.error("\u274C STACKSPOT_QA_AGENT_ID not configured.");
+    tui.log.info("Please run: set STACKSPOT_QA_AGENT_ID=<your-id>");
+    return;
+  }
+  await mcpClient.connect();
+  tui.intro("\u{1F988} Shark QA Agent");
+  tui.log.info("Connecting to Chrome DevTools...");
+  const realm = await getActiveRealm();
+  const token = await tokenStorage.getToken(realm);
+  if (!token) {
+    tui.log.error('Authentication required. Run "shark login".');
+    return;
+  }
+  let projectContext = "";
+  try {
+    const contextPath = path7.join(process.cwd(), "_sharkrc", "project-context.md");
+    if (fs8.existsSync(contextPath)) {
+      projectContext = fs8.readFileSync(contextPath, "utf-8");
+      tui.log.info(`\u{1F4D8} Context loaded from: _sharkrc/project-context.md`);
+    }
+  } catch (e) {
+  }
+  let userMessage = `CONTEXTO DO PROJETO:
+${projectContext}
+
+`;
+  if (options.initialUrl) {
+    userMessage += `URL ALVO: ${options.initialUrl}
+`;
+  }
+  if (options.scenario) {
+    userMessage += `CEN\xC1RIO DE TESTE: ${options.scenario}
+`;
+  } else {
+    userMessage += `Por favor, aguarde instru\xE7\xF5es do usu\xE1rio.`;
+  }
+  let keepRunning = true;
+  while (keepRunning) {
+    const spinner = tui.spinner();
+    spinner.start("\u{1F916} Shark QA is thinking...");
+    let agentResponseText = "";
+    let agentResponse = null;
+    try {
+      const existingConversationId = await conversationManager.getConversationId(AGENT_TYPE5);
+      await sseClient.streamAgentResponse(
+        `https://genai-inference-app.stackspot.com/v1/agent/${AGENT_ID5}/chat`,
+        {
+          user_prompt: userMessage,
+          streaming: true,
+          use_conversation: true,
+          conversation_id: existingConversationId
+        },
+        {
+          "Authorization": `Bearer ${token}`
+        },
+        {
+          onChunk: (chunk) => {
+            agentResponseText += chunk;
+            if (agentResponseText.length > 10 && agentResponseText.trim().startsWith("{")) {
+              spinner.message("Receiving structured plan...");
+            }
+          },
+          onComplete: (fullText, metadata) => {
+            try {
+              if (metadata?.conversation_id) {
+                conversationManager.saveConversationId(AGENT_TYPE5, metadata.conversation_id);
+              }
+              agentResponse = parseAgentResponse(fullText || agentResponseText);
+            } catch (e) {
+              tui.log.error(`Parse Error: ${e.message}`);
+              agentResponse = { actions: [], summary: "Error parsing response", message: fullText };
+            }
+          }
+        }
+      );
+      spinner.stop("Response Received");
+    } catch (error) {
+      spinner.stop("Communication Error", 1);
+      tui.log.error(error.message);
+      keepRunning = false;
+      break;
+    }
+    if (!agentResponse) continue;
+    if (agentResponse.summary) {
+      tui.log.info(colors.primary(`\u{1F4CB} Plan: ${agentResponse.summary}`));
+    }
+    if (agentResponse.actions.length === 0) {
+      const reply = await tui.text({
+        message: "\u{1F916} Shark QA:",
+        placeholder: "Your reply..."
+      });
+      if (tui.isCancel(reply)) {
+        keepRunning = false;
+      } else {
+        userMessage = reply;
+      }
+      continue;
+    }
+    for (const action of agentResponse.actions) {
+      tui.log.info(colors.dim(`Executing: ${action.type}`));
+      let result = "";
+      try {
+        switch (action.type) {
+          case "talk_with_user":
+            const reply = await tui.text({
+              message: `\u{1F916} ${action.content}`
+            });
+            if (tui.isCancel(reply)) keepRunning = false;
+            else result = reply;
+            break;
+          case "use_mcp_tool":
+            if (action.tool_name) {
+              tui.log.info(`\u{1F527} MCP Tool: ${colors.bold(action.tool_name)}`);
+              let args = {};
+              try {
+                args = typeof action.tool_args === "string" ? JSON.parse(action.tool_args) : action.tool_args || {};
+              } catch (e) {
+                tui.log.warning("Failed to parse tool_args, using empty object");
+              }
+              const mcpResult = await mcpClient.callTool(action.tool_name, args);
+              result = JSON.stringify(mcpResult);
+              tui.log.success(`Result: ${result.substring(0, 100)}...`);
+            }
+            break;
+          case "create_file":
+            if (action.path && action.content) {
+              const fullPath = path7.resolve(process.cwd(), action.path);
+              fs8.writeFileSync(fullPath, action.content);
+              tui.log.success(`File created: ${action.path}`);
+              result = "File created successfully.";
+            }
+            break;
+          case "read_file":
+            result = handleReadFile(action.path || "");
+            break;
+          case "run_command":
+            const confirm = await tui.confirm({ message: `Run command: ${action.command}?` });
+            if (confirm && action.command) {
+              result = await handleRunCommand(action.command);
+            } else {
+              result = "Command execution denied by user.";
+            }
+            break;
+          default:
+            result = `Action ${action.type} not fully implemented in local client.`;
+        }
+      } catch (e) {
+        result = `Error executing ${action.type}: ${e.message}`;
+        tui.log.error(result);
+      }
+      userMessage = `[Action ${action.type} Result]:
+${result}
+
+`;
+    }
+  }
+  await mcpClient.close();
+  tui.outro("\u{1F988} Shark QA Session Ended");
+}
+
+// src/commands/qa.ts
+var qaCommand = new Command4("qa").description("Start the Shark QA Agent to test web applications").option("--url <url>", "Initial URL to test").option("--scenario <scenario>", "Scenario description or test case to execute").action(async (options) => {
+  try {
+    await runQAAgent({
+      initialUrl: options.url,
+      scenario: options.scenario
+    });
+  } catch (error) {
+    console.error("Failed to run QA Agent:", error.message);
+    process.exit(1);
+  }
+});
+
+// src/bin/shark.ts
+crashHandler.init();
+var program = new Command5();
+program.name("shark").description("Shark CLI: AI-Native Collaborative Development Tool").version("0.0.1");
+program.addCommand(loginCommand);
+program.addCommand(initCommand);
+program.addCommand(scanCommand);
+program.addCommand(devCommand);
+program.addCommand(qaCommand);
+program.command("ba").description("Start Business Analyst Agent interactive session").option("--id <agent_id>", "Override Agent ID").action(async (options) => {
+  try {
+    await interactiveBusinessAnalyst();
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+});
+program.command("spec").description("Start Specification Agent interactive session").option("--id <agent_id>", "Override Agent ID").option("--briefing <path>", "Path to briefing file").action(async (options) => {
+  try {
+    await interactiveSpecificationAgent({
+      agentId: options.id,
+      briefingPath: options.briefing
+    });
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+});
+program.command("config").description("Manage global configuration").action(configCommand.action);
+process.on("unhandledRejection", (err) => {
+  console.error(colors.error("\u274C Unhandled Error:"), err);
+  process.exit(1);
+});
+program.parse(process.argv);
+//# sourceMappingURL=shark.js.map