shark-ai 0.3.17 → 0.4.0

package/dist/bin/shark.js

@@ -342,6 +342,20 @@ var SSEClient = class {
       if (!response.body) {
         throw new Error("Response body is null");
       }
+      const contentType = response.headers.get("content-type") || "";
+      const isJson = contentType.includes("application/json");
+      if (isJson) {
+        const jsonBody = await response.json();
+        FileLogger.log("SSE", "Received Non-Streaming JSON Response", { length: JSON.stringify(jsonBody).length });
+        let content = "";
+        if (typeof jsonBody === "string") content = jsonBody;
+        else if (jsonBody.message) content = jsonBody.message;
+        else if (jsonBody.choices?.[0]?.message?.content) content = jsonBody.choices[0].message.content;
+        else content = JSON.stringify(jsonBody);
+        if (onChunk) onChunk(content);
+        if (onComplete) onComplete(content, jsonBody);
+        return;
+      }
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
       let buffer = "";
@@ -403,7 +417,35 @@ 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", "modify_ast", "search_ast", "delete_file", "talk_with_user", "list_files", "read_file", "search_file", "run_command", "use_mcp_tool"]),
+  type: z2.enum([
+    "create_file",
+    "modify_file",
+    "modify_ast",
+    "search_ast",
+    "delete_file",
+    "talk_with_user",
+    "list_files",
+    "read_file",
+    "search_file",
+    "run_command",
+    "use_mcp_tool",
+    // New AST Tools
+    "ast_list_structure",
+    "ast_add_method",
+    "ast_modify_method",
+    "ast_remove_method",
+    "ast_add_class",
+    "ast_add_property",
+    "ast_remove_property",
+    "ast_add_decorator",
+    "ast_add_interface",
+    "ast_add_type_alias",
+    "ast_add_function",
+    "ast_remove_function",
+    "ast_add_import",
+    "ast_remove_import",
+    "ast_organize_imports"
+  ]),
   path: z2.string().nullable().optional(),
   // Nullable for strict mode combatibility
   content: z2.string().nullable().optional(),
@@ -419,6 +461,22 @@ var AgentActionSchema = z2.object({
   language: z2.string().nullable().optional(),
   file_path: z2.string().nullable().optional(),
   // Alias for path in ast-grep actions
+  // New AST Tool Specific Fields
+  class_name: z2.string().nullable().optional(),
+  method_name: z2.string().nullable().optional(),
+  method_code: z2.string().nullable().optional(),
+  property_name: z2.string().nullable().optional(),
+  property_code: z2.string().nullable().optional(),
+  extends_class: z2.string().nullable().optional(),
+  implements_interfaces: z2.array(z2.string()).nullable().optional(),
+  decorator_code: z2.string().nullable().optional(),
+  interface_code: z2.string().nullable().optional(),
+  type_code: z2.string().nullable().optional(),
+  function_name: z2.string().nullable().optional(),
+  function_code: z2.string().nullable().optional(),
+  import_statement: z2.string().nullable().optional(),
+  module_path: z2.string().nullable().optional(),
+  new_body: z2.string().nullable().optional(),
   // Preview confirmation
   confirmed: z2.boolean().nullable().optional()
 });
@@ -772,19 +830,404 @@ async function interactiveBusinessAnalyst() {
 }
 
 // src/core/agents/specification-agent.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path7 from "path";
 
 // src/core/agents/agent-tools.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path6 from "path";
 import fg from "fast-glob";
 import { exec } from "child_process";
 import { promisify } from "util";
 import { fileURLToPath } from "url";
 
+// src/core/ast-editing/editors/code-editor-factory.ts
+import * as path4 from "path";
+
+// src/core/ast-editing/editors/typescript-editor.ts
+import { Project, SyntaxKind } from "ts-morph";
+import * as path3 from "path";
+import * as fs3 from "fs";
+var TypeScriptEditor = class {
+  project;
+  constructor() {
+    this.project = new Project({
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: {
+        target: 99,
+        // ESNext
+        module: 99
+        // ESNext
+      }
+    });
+  }
+  /**
+   * Get or add source file to project
+   */
+  getSourceFile(filePath) {
+    const absolutePath = path3.resolve(filePath);
+    let sourceFile = this.project.getSourceFile(absolutePath);
+    if (!sourceFile) {
+      if (!fs3.existsSync(absolutePath)) {
+        throw new Error(`File not found: ${absolutePath}`);
+      }
+      sourceFile = this.project.addSourceFileAtPath(absolutePath);
+    }
+    return sourceFile;
+  }
+  /**
+   * Get class declaration by name
+   */
+  getClass(sourceFile, className) {
+    const classDecl = sourceFile.getClass(className);
+    if (!classDecl) {
+      throw new Error(`Class "${className}" not found in ${sourceFile.getFilePath()}`);
+    }
+    return classDecl;
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: listStructure
+  // ═══════════════════════════════════════════════════════
+  async listStructure(filePath) {
+    const sourceFile = this.getSourceFile(filePath);
+    const classes = sourceFile.getClasses().map((cls) => ({
+      name: cls.getName() || "<anonymous>",
+      methods: cls.getMethods().map((m) => this.extractMethodInfo(m)),
+      properties: cls.getProperties().map((p) => this.extractPropertyInfo(p)),
+      decorators: cls.getDecorators().map((d) => d.getText()),
+      extendsClass: cls.getExtends()?.getText(),
+      implementsInterfaces: cls.getImplements().map((i) => i.getText())
+    }));
+    const interfaces = sourceFile.getInterfaces().map((iface) => ({
+      name: iface.getName(),
+      properties: iface.getProperties().map((p) => this.extractPropertyInfo(p)),
+      extends: iface.getExtends().map((e) => e.getText())
+    }));
+    const functions = sourceFile.getFunctions().map((fn) => ({
+      name: fn.getName() || "<anonymous>",
+      parameters: fn.getParameters().map((p) => ({
+        name: p.getName(),
+        type: p.getType().getText(),
+        isOptional: p.isOptional()
+      })),
+      returnType: fn.getReturnType().getText(),
+      isAsync: fn.isAsync(),
+      isExported: fn.isExported()
+    }));
+    const imports = sourceFile.getImportDeclarations().map((imp) => ({
+      modulePath: imp.getModuleSpecifierValue(),
+      isDefault: !!imp.getDefaultImport(),
+      namedImports: imp.getNamedImports().map((n) => n.getName()),
+      namespaceImport: imp.getNamespaceImport()?.getText()
+    }));
+    const exports = sourceFile.getExportedDeclarations();
+    const exportInfo = Array.from(exports.entries()).flatMap(
+      ([name, declarations]) => declarations.map((decl) => ({
+        name,
+        type: this.getDeclarationType(decl),
+        isDefault: sourceFile.getDefaultExportSymbol()?.getName() === name
+      }))
+    );
+    return {
+      classes,
+      interfaces,
+      functions,
+      imports,
+      exports: exportInfo
+    };
+  }
+  extractMethodInfo(method) {
+    return {
+      name: method.getName(),
+      parameters: method.getParameters().map((p) => ({
+        name: p.getName(),
+        type: p.getType().getText(),
+        isOptional: p.isOptional()
+      })),
+      returnType: method.getReturnType().getText(),
+      isAsync: method.isAsync(),
+      isStatic: method.isStatic(),
+      visibility: this.getVisibility(method),
+      decorators: method.getDecorators().map((d) => d.getText())
+    };
+  }
+  extractPropertyInfo(property) {
+    return {
+      name: property.getName(),
+      type: property.getType()?.getText(),
+      visibility: this.getVisibility(property),
+      isReadonly: property.isReadonly(),
+      initializer: property.getInitializer()?.getText()
+    };
+  }
+  getVisibility(node) {
+    if (node.hasModifier?.(SyntaxKind.PrivateKeyword)) return "private";
+    if (node.hasModifier?.(SyntaxKind.ProtectedKeyword)) return "protected";
+    return "public";
+  }
+  getDeclarationType(decl) {
+    if (decl.getKind() === SyntaxKind.ClassDeclaration) return "class";
+    if (decl.getKind() === SyntaxKind.FunctionDeclaration) return "function";
+    if (decl.getKind() === SyntaxKind.InterfaceDeclaration) return "interface";
+    if (decl.getKind() === SyntaxKind.TypeAliasDeclaration) return "type";
+    return "const";
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: Class Operations
+  // ═══════════════════════════════════════════════════════
+  async addClass(filePath, className, options) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.addClass({
+        name: className,
+        extends: options?.extendsClass,
+        implements: options?.implementsInterfaces,
+        isExported: true
+      });
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add class "${className}":`, error);
+      return false;
+    }
+  }
+  async addProperty(filePath, className, propertyCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const closeBrace = classDecl.getEnd() - 1;
+      classDecl.insertText(closeBrace, `
+  ${propertyCode}`);
+      classDecl.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add property to "${className}":`, error);
+      return false;
+    }
+  }
+  async removeProperty(filePath, className, propertyName) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const property = classDecl.getProperty(propertyName);
+      if (!property) {
+        throw new Error(`Property "${propertyName}" not found in class "${className}"`);
+      }
+      property.remove();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to remove property "${propertyName}":`, error);
+      return false;
+    }
+  }
+  async addMethod(filePath, className, methodCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const closeBrace = classDecl.getEnd() - 1;
+      classDecl.insertText(closeBrace, `
+  ${methodCode}
+`);
+      classDecl.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add method to "${className}":`, error);
+      return false;
+    }
+  }
+  async modifyMethod(filePath, className, methodName, newBody) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const method = classDecl.getMethod(methodName);
+      if (!method) {
+        throw new Error(`Method "${methodName}" not found in class "${className}"`);
+      }
+      method.setBodyText(newBody);
+      method.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to modify method "${methodName}":`, error);
+      return false;
+    }
+  }
+  async removeMethod(filePath, className, methodName) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const method = classDecl.getMethod(methodName);
+      if (!method) {
+        throw new Error(`Method "${methodName}" not found in class "${className}"`);
+      }
+      method.remove();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to remove method "${methodName}":`, error);
+      return false;
+    }
+  }
+  async addDecorator(filePath, className, decoratorCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const classDecl = this.getClass(sourceFile, className);
+      const start = classDecl.getStart();
+      sourceFile.insertText(start, `${decoratorCode}
+`);
+      sourceFile.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add decorator to "${className}":`, error);
+      return false;
+    }
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: Interface/Type Operations
+  // ═══════════════════════════════════════════════════════
+  async addInterface(filePath, interfaceCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.insertText(sourceFile.getEnd(), `
+
+${interfaceCode}`);
+      sourceFile.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add interface:`, error);
+      return false;
+    }
+  }
+  async addTypeAlias(filePath, typeCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.insertText(sourceFile.getEnd(), `
+
+${typeCode}`);
+      sourceFile.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add type alias:`, error);
+      return false;
+    }
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: Function Operations
+  // ═══════════════════════════════════════════════════════
+  async addFunction(filePath, functionCode) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.insertText(sourceFile.getEnd(), `
+
+${functionCode}`);
+      sourceFile.formatText();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add function:`, error);
+      return false;
+    }
+  }
+  async removeFunction(filePath, functionName) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const func = sourceFile.getFunction(functionName);
+      if (!func) {
+        throw new Error(`Function "${functionName}" not found`);
+      }
+      func.remove();
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to remove function "${functionName}":`, error);
+      return false;
+    }
+  }
+  // ═══════════════════════════════════════════════════════
+  // IMPLEMENTATION: Import/Export Operations
+  // ═══════════════════════════════════════════════════════
+  async addImport(filePath, importStatement) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const lastImport = sourceFile.getImportDeclarations().pop();
+      const pos = lastImport ? lastImport.getEnd() : 0;
+      sourceFile.insertText(pos, `
+${importStatement}`);
+      this.organizeImports(filePath);
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to add import:`, error);
+      return false;
+    }
+  }
+  async removeImport(filePath, modulePath) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const importDecls = sourceFile.getImportDeclarations().filter((imp) => imp.getModuleSpecifierValue() === modulePath);
+      if (importDecls.length === 0) {
+        throw new Error(`Import from "${modulePath}" not found`);
+      }
+      importDecls.forEach((d) => d.remove());
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to remove import from "${modulePath}":`, error);
+      return false;
+    }
+  }
+  async organizeImports(filePath) {
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      sourceFile.organizeImports();
+      const imports = sourceFile.getImportDeclarations();
+      const importStructure = imports.map((i) => i.getStructure());
+      importStructure.sort((a, b) => {
+        return a.moduleSpecifier.localeCompare(b.moduleSpecifier);
+      });
+      imports.forEach((i) => i.remove());
+      sourceFile.addImportDeclarations(importStructure);
+      await sourceFile.save();
+      return true;
+    } catch (error) {
+      console.error(`Failed to organize imports:`, error);
+      return false;
+    }
+  }
+};
+
+// src/core/ast-editing/editors/code-editor-factory.ts
+var CodeEditorFactory = class {
+  static tsEditor = null;
+  /**
+   * Returns appropriate editor for the file, or null if AST editing not supported
+   */
+  static getEditor(filePath) {
+    const ext = path4.extname(filePath).toLowerCase();
+    if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+      if (!this.tsEditor) {
+        this.tsEditor = new TypeScriptEditor();
+      }
+      return this.tsEditor;
+    }
+    return null;
+  }
+  /**
+   * Clear cached editors (useful for testing)
+   */
+  static clearCache() {
+    this.tsEditor = null;
+  }
+};
+
 // src/core/services/code-review.service.ts
-import path3 from "path";
+import path5 from "path";
 var CodeReviewService = class {
   /**
    * Reviews the code modification and returns a status/feedback string.
@@ -793,7 +1236,7 @@ var CodeReviewService = class {
   static async reviewCode(filePath, newContent) {
     const config = ConfigManager.getInstance().getConfig();
     const validation = config.validation || { llmReviewExtensions: [".ts", ".tsx"], syntaxCheckExtensions: ["*"] };
-    const ext = path3.extname(filePath).toLowerCase();
+    const ext = path5.extname(filePath).toLowerCase();
     const needsLlmReview = validation.llmReviewExtensions.includes(ext) || validation.llmReviewExtensions.includes("*");
     if (needsLlmReview) {
       return await this.performLlmReview(filePath, newContent);
@@ -818,7 +1261,7 @@ var CodeReviewService = class {
     try {
       const realm = await getActiveRealm();
       const token = await ensureValidToken(realm);
-      const prompt = `You are a Code Review Specialist. Analyze the following code modification for file: ${path3.basename(filePath)}
+      const prompt = `You are a Code Review Specialist. Analyze the following code modification for file: ${path5.basename(filePath)}
 
 NEW CODE TO BE ADDED:
 \`\`\`
@@ -833,8 +1276,8 @@ Provide a concise review focusing on:
 Respond in JSON format with status, issues array, and summary.`;
       const payload = {
         user_prompt: prompt,
-        streaming: false,
-        use_conversation: false,
+        streaming: true,
+        use_conversation: true,
         stackspot_knowledge: false
       };
       const url = `${STACKSPOT_AGENT_API_BASE}/v1/agent/${agentId}/chat`;
@@ -920,9 +1363,9 @@ function detectLineEnding(content) {
 }
 function handleListFiles(dirPath) {
   try {
-    const fullPath = path4.resolve(process.cwd(), dirPath);
-    if (!fs3.existsSync(fullPath)) return `Error: Directory ${dirPath} does not exist.`;
-    const items = fs3.readdirSync(fullPath, { withFileTypes: true });
+    const fullPath = path6.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");
@@ -932,11 +1375,11 @@ function handleListFiles(dirPath) {
 }
 function handleReadFile(filePath, showLineNumbers = true) {
   try {
-    const fullPath = path4.resolve(process.cwd(), filePath);
-    if (!fs3.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
-    const stats = fs3.statSync(fullPath);
+    const fullPath = path6.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.`;
-    const content = fs3.readFileSync(fullPath, "utf-8");
+    const content = fs4.readFileSync(fullPath, "utf-8");
     if (showLineNumbers) {
       const lines = content.split("\n");
       return lines.map((line, idx) => `${idx + 1}: ${line}`).join("\n");
@@ -948,11 +1391,11 @@ function handleReadFile(filePath, showLineNumbers = true) {
 }
 function replaceLineRange(filePath, startLine, endLine, newContent, tui2) {
   try {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       tui2.log.error(`\u274C File not found for modification: ${filePath}`);
       return false;
     }
-    const currentFileContent = fs3.readFileSync(filePath, "utf-8");
+    const currentFileContent = fs4.readFileSync(filePath, "utf-8");
     const lineEnding = detectLineEnding(currentFileContent);
     const lines = currentFileContent.split(lineEnding);
     if (startLine < 1 || startLine > lines.length) {
@@ -970,7 +1413,7 @@ function replaceLineRange(filePath, startLine, endLine, newContent, tui2) {
     const result = [...before, ...normalizedNewLines, ...after].join(lineEnding);
     const BOM = "\uFEFF";
     const finalContent = result.startsWith(BOM) ? result : BOM + result;
-    fs3.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
+    fs4.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
     tui2.log.success(`\u2705 Replaced lines ${startLine}-${endLine} in ${filePath}`);
     return true;
   } catch (e) {
@@ -980,9 +1423,9 @@ function replaceLineRange(filePath, startLine, endLine, newContent, tui2) {
 }
 async function generateFilePreview(filePath, startLine, endLine, newContent) {
   try {
-    const fullPath = path4.resolve(process.cwd(), filePath);
-    if (!fs3.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
-    const content = fs3.readFileSync(fullPath, "utf-8");
+    const fullPath = path6.resolve(process.cwd(), filePath);
+    if (!fs4.existsSync(fullPath)) return `Error: File ${filePath} does not exist.`;
+    const content = fs4.readFileSync(fullPath, "utf-8");
     const lines = content.split(/\r\n|\r|\n/);
     const startIdx = startLine - 1;
     const endIdx = endLine - 1;
@@ -1029,11 +1472,11 @@ function handleSearchFile(pattern) {
   }
 }
 function startSmartReplace(filePath, newContent, targetContent, tui2) {
-  if (!fs3.existsSync(filePath)) {
+  if (!fs4.existsSync(filePath)) {
     tui2.log.error(`\u274C File not found for modification: ${filePath}`);
     return false;
   }
-  const currentFileContent = fs3.readFileSync(filePath, "utf-8");
+  const currentFileContent = fs4.readFileSync(filePath, "utf-8");
   const normalizedTarget = targetContent.replace(/\r\n/g, "\n");
   const normalizedContent = currentFileContent.replace(/\r\n/g, "\n");
   if (!normalizedContent.includes(normalizedTarget)) {
@@ -1050,7 +1493,7 @@ function startSmartReplace(filePath, newContent, targetContent, tui2) {
   const BOM = "\uFEFF";
   const updatedContent = currentFileContent.replace(targetContent, newContent);
   const finalContent = updatedContent.startsWith(BOM) ? updatedContent : BOM + updatedContent;
-  fs3.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
+  fs4.writeFileSync(filePath, finalContent, { encoding: "utf-8" });
   tui2.log.success(`\u2705 Smart Replace Applied: ${filePath}`);
   return true;
 }
@@ -1058,7 +1501,7 @@ async function handleRunCommand(command) {
   const { spawn } = await import("child_process");
   try {
     tui.log.info(`\u{1F4BB} Executing: ${colors.dim(command)}`);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const child = spawn(command, {
         shell: true,
         stdio: ["ignore", "pipe", "pipe"],
@@ -1068,7 +1511,7 @@ async function handleRunCommand(command) {
       let stderr = "";
       const timer = setTimeout(() => {
         child.kill();
-        resolve(`Error: Command timed out after 5 minutes.
+        resolve2(`Error: Command timed out after 5 minutes.
 Output so far:
 ${stdout}
 ${stderr}`);
@@ -1083,9 +1526,9 @@ ${stderr}`);
       child.on("close", (code) => {
         clearTimeout(timer);
         if (code === 0) {
-          resolve(stdout.trim() || "Command executed successfully (no output).");
+          resolve2(stdout.trim() || "Command executed successfully (no output).");
         } else {
-          resolve(`Command failed with exit code ${code}.
+          resolve2(`Command failed with exit code ${code}.
 STDERR:
 ${stderr}
 STDOUT:
@@ -1094,7 +1537,7 @@ ${stdout}`);
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        resolve(`Error executing command: ${err.message}`);
+        resolve2(`Error executing command: ${err.message}`);
       });
     });
   } catch (e) {
@@ -1106,20 +1549,20 @@ function resolveAstGrepCommand() {
   const binName = isWin ? "sg.cmd" : "sg";
   try {
     const currentFile = fileURLToPath(import.meta.url);
-    let dir = path4.dirname(currentFile);
+    let dir = path6.dirname(currentFile);
     for (let i = 0; i < 5; i++) {
-      const candidate = path4.join(dir, "node_modules", ".bin", binName);
-      if (fs3.existsSync(candidate)) {
+      const candidate = path6.join(dir, "node_modules", ".bin", binName);
+      if (fs4.existsSync(candidate)) {
         return `"${candidate}"`;
       }
-      const parent = path4.dirname(dir);
+      const parent = path6.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
   } catch (e) {
   }
-  const cwdBin = path4.resolve(process.cwd(), "node_modules", ".bin", binName);
-  if (fs3.existsSync(cwdBin)) {
+  const cwdBin = path6.resolve(process.cwd(), "node_modules", ".bin", binName);
+  if (fs4.existsSync(cwdBin)) {
     return `"${cwdBin}"`;
   }
   return "npx sg";
@@ -1127,13 +1570,13 @@ function resolveAstGrepCommand() {
 async function astGrepSearch(pattern, filePath, language, tui2) {
   const { spawn } = await import("child_process");
   try {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       return `\u274C File not found: ${filePath}`;
     }
     const sgCmd = resolveAstGrepCommand();
     const cmd = `${sgCmd} run -p "${pattern}" -l ${language} --json ${filePath}`;
     tui2.log.info(`\u{1F50D} [AST-GREP] Searching: ${cmd}`);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const child = spawn(cmd, {
         shell: true,
         stdio: ["ignore", "pipe", "pipe"],
@@ -1147,19 +1590,19 @@ async function astGrepSearch(pattern, filePath, language, tui2) {
       child.stderr.on("data", (data) => stderr += data.toString());
       child.on("close", (code) => {
         if (code === 0 && stdout) {
-          resolve(stdout);
+          resolve2(stdout);
         } else if (code === 1 && !stderr) {
-          resolve("No structural matches found.");
+          resolve2("No structural matches found.");
         } else {
-          if (!stdout && !stderr) resolve("No structural matches found.");
+          if (!stdout && !stderr) resolve2("No structural matches found.");
           else {
             tui2.log.error(`\u274C ast-grep search error (code ${code}): ${stderr}`);
-            resolve(`Error executing ast-grep search: ${stderr || stdout}`);
+            resolve2(`Error executing ast-grep search: ${stderr || stdout}`);
           }
         }
       });
       child.on("error", (err) => {
-        resolve(`Error executing ast-grep search: ${err.message}`);
+        resolve2(`Error executing ast-grep search: ${err.message}`);
       });
     });
   } catch (e) {
@@ -1170,14 +1613,14 @@ async function astGrepSearch(pattern, filePath, language, tui2) {
 async function astGrepRewrite(pattern, fix, filePath, language, tui2) {
   const { spawn } = await import("child_process");
   try {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       tui2.log.error(`\u274C File not found for AST modification: ${filePath}`);
       return false;
     }
     const sgCmd = resolveAstGrepCommand();
     const cmd = `${sgCmd} run -p "${pattern}" -r "${fix}" -l ${language} ${filePath} --update-all`;
     tui2.log.info(`\u270F\uFE0F [AST-GREP] Rewriting: pattern="${pattern}" fix="${fix.substring(0, 50)}..."`);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const child = spawn(cmd, {
         shell: true,
         stdio: ["ignore", "pipe", "pipe"],
@@ -1188,15 +1631,15 @@ async function astGrepRewrite(pattern, fix, filePath, language, tui2) {
       child.on("close", (code) => {
         if (code === 0) {
           tui2.log.success(`\u2705 AST Rewrite applied to ${filePath}`);
-          resolve(true);
+          resolve2(true);
         } else {
           tui2.log.error(`\u274C AST Rewrite failed (code ${code}): ${stderr}`);
-          resolve(false);
+          resolve2(false);
         }
       });
       child.on("error", (err) => {
         tui2.log.error(`\u274C AST Rewrite spawn error: ${err.message}`);
-        resolve(false);
+        resolve2(false);
       });
     });
   } catch (e) {
@@ -1204,6 +1647,160 @@ async function astGrepRewrite(pattern, fix, filePath, language, tui2) {
     return false;
   }
 }
+async function astListStructure(filePath) {
+  try {
+    const editor = CodeEditorFactory.getEditor(filePath);
+    if (!editor) {
+      return `[AST Error] File type not supported: ${filePath}. Use read_file instead.`;
+    }
+    const structure = await editor.listStructure(filePath);
+    let output = `[AST Structure of ${filePath}]
+
+`;
+    if (structure.classes.length > 0) {
+      output += `CLASSES:
+`;
+      structure.classes.forEach((cls) => {
+        output += `  - ${cls.name}`;
+        if (cls.extendsClass) output += ` extends ${cls.extendsClass}`;
+        if (cls.implementsInterfaces.length > 0) {
+          output += ` implements ${cls.implementsInterfaces.join(", ")}`;
+        }
+        output += `
+`;
+        if (cls.decorators.length > 0) {
+          output += `    Decorators: ${cls.decorators.join(", ")}
+`;
+        }
+        if (cls.properties.length > 0) {
+          output += `    Properties:
+`;
+          cls.properties.forEach((prop) => {
+            output += `      - ${prop.visibility} ${prop.name}: ${prop.type}
+`;
+          });
+        }
+        if (cls.methods.length > 0) {
+          output += `    Methods:
+`;
+          cls.methods.forEach((method) => {
+            const params = method.parameters.map((p) => `${p.name}: ${p.type}`).join(", ");
+            output += `      - ${method.visibility} ${method.name}(${params}): ${method.returnType}
+`;
+          });
+        }
+        output += `
+`;
+      });
+    }
+    if (structure.interfaces.length > 0) {
+      output += `INTERFACES:
+`;
+      structure.interfaces.forEach((iface) => {
+        output += `  - ${iface.name}
+`;
+        iface.properties.forEach((prop) => {
+          output += `      ${prop.name}: ${prop.type}
+`;
+        });
+      });
+      output += `
+`;
+    }
+    if (structure.functions.length > 0) {
+      output += `FUNCTIONS:
+`;
+      structure.functions.forEach((fn) => {
+        const params = fn.parameters.map((p) => `${p.name}: ${p.type}`).join(", ");
+        output += `  - ${fn.name}(${params}): ${fn.returnType}
+`;
+      });
+      output += `
+`;
+    }
+    if (structure.imports.length > 0) {
+      output += `IMPORTS:
+`;
+      structure.imports.forEach((imp) => {
+        output += `  - from "${imp.modulePath}": ${imp.namedImports.join(", ")}
+`;
+      });
+    }
+    return output;
+  } catch (error) {
+    return `[AST Error] ${error.message}`;
+  }
+}
+async function astAddMethod(filePath, className, methodCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addMethod(filePath, className, methodCode);
+}
+async function astAddClass(filePath, className, extendsClass, implementsInterfaces) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addClass(filePath, className, { extendsClass, implementsInterfaces });
+}
+async function astAddProperty(filePath, className, propertyCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addProperty(filePath, className, propertyCode);
+}
+async function astRemoveProperty(filePath, className, propertyName) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.removeProperty(filePath, className, propertyName);
+}
+async function astModifyMethod(filePath, className, methodName, newBody) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.modifyMethod(filePath, className, methodName, newBody);
+}
+async function astRemoveMethod(filePath, className, methodName) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.removeMethod(filePath, className, methodName);
+}
+async function astAddDecorator(filePath, className, decoratorCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addDecorator(filePath, className, decoratorCode);
+}
+async function astAddInterface(filePath, interfaceCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addInterface(filePath, interfaceCode);
+}
+async function astAddTypeAlias(filePath, typeCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addTypeAlias(filePath, typeCode);
+}
+async function astAddFunction(filePath, functionCode) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addFunction(filePath, functionCode);
+}
+async function astRemoveFunction(filePath, functionName) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.removeFunction(filePath, functionName);
+}
+async function astAddImport(filePath, importStatement) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.addImport(filePath, importStatement);
+}
+async function astRemoveImport(filePath, modulePath) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.removeImport(filePath, modulePath);
+}
+async function astOrganizeImports(filePath) {
+  const editor = CodeEditorFactory.getEditor(filePath);
+  if (!editor) throw new Error(`AST editing not supported for: ${filePath}`);
+  return await editor.organizeImports(filePath);
+}
 
 // src/core/agents/specification-agent.ts
 var AGENT_TYPE2 = "specification_agent";
@@ -1218,23 +1815,23 @@ async function interactiveSpecificationAgent(options = {}) {
   tui.intro("\u{1F3D7}\uFE0F  Specification Agent");
   const projectRoot = process.cwd();
   let contextContent = "";
-  const contextPath = path5.resolve(projectRoot, "_sharkrc", "project-context.md");
-  if (fs4.existsSync(contextPath)) {
+  const contextPath = path7.resolve(projectRoot, "_sharkrc", "project-context.md");
+  if (fs5.existsSync(contextPath)) {
     try {
-      contextContent = fs4.readFileSync(contextPath, "utf-8");
-      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path5.relative(projectRoot, contextPath))}`);
+      contextContent = fs5.readFileSync(contextPath, "utf-8");
+      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path7.relative(projectRoot, contextPath))}`);
     } catch (e) {
       tui.log.warning(`Failed to read context file: ${e}`);
     }
   }
   let briefingContent = "";
-  if (options.briefingPath && fs4.existsSync(options.briefingPath)) {
-    briefingContent = fs4.readFileSync(options.briefingPath, "utf-8");
+  if (options.briefingPath && fs5.existsSync(options.briefingPath)) {
+    briefingContent = fs5.readFileSync(options.briefingPath, "utf-8");
     tui.log.info(`\u{1F4C4} Briefing loaded from: ${colors.dim(options.briefingPath)}`);
   } else {
-    const sharkRcBriefing = path5.resolve(projectRoot, "_sharkrc", "briefing.md");
-    if (fs4.existsSync(sharkRcBriefing)) {
-      briefingContent = fs4.readFileSync(sharkRcBriefing, "utf-8");
+    const sharkRcBriefing = path7.resolve(projectRoot, "_sharkrc", "briefing.md");
+    if (fs5.existsSync(sharkRcBriefing)) {
+      briefingContent = fs5.readFileSync(sharkRcBriefing, "utf-8");
       tui.log.info(`\u{1F4C4} Standard Briefing loaded: ${colors.dim("_sharkrc/briefing.md")}`);
     } else {
       tui.log.info(colors.dim("\u2139\uFE0F No briefing file found in _sharkrc/briefing.md. Starting in interactive mode."));
@@ -1349,9 +1946,9 @@ ${result}
                     const BOM = "\uFEFF";
                     const contentToWrite = action.content || "";
                     const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                    const dir = path5.dirname(action.path);
-                    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
-                    fs4.writeFileSync(action.path, finalContent, { encoding: "utf-8" });
+                    const dir = path7.dirname(action.path);
+                    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+                    fs5.writeFileSync(action.path, finalContent, { encoding: "utf-8" });
                     tui.log.success(`\u2705 Created: ${action.path}`);
                     executionResults += `[Action create_file(${action.path})]: Success
 
@@ -1369,7 +1966,7 @@ ${result}
 `;
                     }
                   } else if (action.type === "delete_file") {
-                    fs4.unlinkSync(action.path);
+                    fs5.unlinkSync(action.path);
                     tui.log.success(`\u2705 Deleted: ${action.path}`);
                     executionResults += `[Action delete_file(${action.path})]: Success
 
@@ -1498,8 +2095,8 @@ async function callSpecAgentApi(prompt, onChunk, agentId) {
 import { Command as Command2 } from "commander";
 
 // src/core/agents/scan-agent.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path8 from "path";
 var AGENT_TYPE3 = "scan_agent";
 function getAgentId3() {
   const config = ConfigManager.getInstance().getConfig();
@@ -1514,29 +2111,29 @@ async function interactiveScanAgent(options = {}) {
   const projectRoot = process.cwd();
   let outputFile;
   if (options.output) {
-    outputFile = path6.resolve(process.cwd(), options.output);
+    outputFile = path8.resolve(process.cwd(), options.output);
   } else {
-    const outputDir = path6.resolve(projectRoot, "_sharkrc");
-    if (!fs5.existsSync(outputDir)) {
-      const stat = fs5.existsSync(outputDir) ? fs5.statSync(outputDir) : null;
+    const outputDir = path8.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 = path6.resolve(projectRoot, "_bmad/project-context");
-        if (!fs5.existsSync(fallbackDir)) fs5.mkdirSync(fallbackDir, { recursive: true });
-        outputFile = path6.join(fallbackDir, "project-context.md");
+        const fallbackDir = path8.resolve(projectRoot, "_bmad/project-context");
+        if (!fs6.existsSync(fallbackDir)) fs6.mkdirSync(fallbackDir, { recursive: true });
+        outputFile = path8.join(fallbackDir, "project-context.md");
       } else {
-        fs5.mkdirSync(outputDir, { recursive: true });
-        outputFile = path6.join(outputDir, "project-context.md");
+        fs6.mkdirSync(outputDir, { recursive: true });
+        outputFile = path8.join(outputDir, "project-context.md");
       }
     } else {
-      fs5.mkdirSync(outputDir, { recursive: true });
-      outputFile = path6.join(outputDir, "project-context.md");
+      fs6.mkdirSync(outputDir, { recursive: true });
+      outputFile = path8.join(outputDir, "project-context.md");
     }
   }
   tui.log.info(`${t("commands.scan.scanningProject")} ${colors.bold(projectRoot)}`);
   tui.log.info(`${t("commands.scan.outputTarget")} ${colors.bold(outputFile)}`);
   tui.log.info(`${t("commands.scan.language")} ${colors.bold(language)}`);
-  const configFileRelative = path6.relative(projectRoot, outputFile);
+  const configFileRelative = path8.relative(projectRoot, outputFile);
   const initialTemplate = `# Project Context
 
 ## Overview
@@ -1569,9 +2166,9 @@ async function interactiveScanAgent(options = {}) {
 ## Key Patterns & Conventions
 [TO BE ANALYZED]
 `;
-  if (!fs5.existsSync(outputFile)) {
+  if (!fs6.existsSync(outputFile)) {
     const BOM = "\uFEFF";
-    fs5.writeFileSync(outputFile, BOM + initialTemplate, { encoding: "utf-8" });
+    fs6.writeFileSync(outputFile, BOM + initialTemplate, { encoding: "utf-8" });
     tui.log.success(`${t("commands.scan.templateCreated")} ${outputFile}`);
   } else {
     tui.log.info(t("commands.scan.fileExists"));
@@ -1869,11 +2466,11 @@ ${result}
 
 `;
           } else if (action.type === "create_file" || action.type === "modify_file") {
-            const resolvedActionPath = path6.resolve(action.path || "");
-            const resolvedTargetPath = path6.resolve(targetPath);
+            const resolvedActionPath = path8.resolve(action.path || "");
+            const resolvedTargetPath = path8.resolve(targetPath);
             let isTarget = resolvedActionPath === resolvedTargetPath;
-            if (!isTarget && path6.basename(action.path || "") === "project-context.md") {
-              tui.log.warning(t("commands.scan.targetRedirect").replace("{0}", action.path || "").replace("{1}", path6.relative(process.cwd(), targetPath)));
+            if (!isTarget && path8.basename(action.path || "") === "project-context.md") {
+              tui.log.warning(t("commands.scan.targetRedirect").replace("{0}", action.path || "").replace("{1}", path8.relative(process.cwd(), targetPath)));
               isTarget = true;
               action.path = targetPath;
             }
@@ -1883,16 +2480,16 @@ ${result}
               if (action.type === "create_file") {
                 const contentToWrite = action.content || "";
                 const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                fs5.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
+                fs6.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
                 tui.log.success(t("commands.scan.generated").replace("{0}", finalPath));
                 fileCreated = true;
               } else {
-                if (fs5.existsSync(finalPath)) {
-                  const currentContent = fs5.readFileSync(finalPath, "utf-8");
+                if (fs6.existsSync(finalPath)) {
+                  const currentContent = fs6.readFileSync(finalPath, "utf-8");
                   if (action.target_content && currentContent.includes(action.target_content)) {
                     const newContent = currentContent.replace(action.target_content, action.content || "");
                     const finalContent = newContent.startsWith(BOM) ? newContent : BOM + newContent;
-                    fs5.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
+                    fs6.writeFileSync(finalPath, finalContent, { encoding: "utf-8" });
                     tui.log.success(t("commands.scan.updated").replace("{0}", finalPath));
                     fileCreated = true;
                   } else {
@@ -1921,7 +2518,7 @@ ${result}
           }
         }
         if (fileCreated) {
-          const currentContent = fs5.readFileSync(targetPath, "utf-8");
+          const currentContent = fs6.readFileSync(targetPath, "utf-8");
           const pendingSections = [];
           const lines = currentContent.split("\n");
           let currentSection = "";
@@ -2013,8 +2610,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 fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path9 from "path";
 var AGENT_TYPE4 = "developer_agent";
 async function validateTypeScript(filePath) {
   try {
@@ -2028,7 +2625,7 @@ async function validateTypeScript(filePath) {
   }
 }
 function validateHtmlTagBalance(filePath) {
-  const content = fs6.readFileSync(filePath, "utf-8");
+  const content = fs7.readFileSync(filePath, "utf-8");
   const stack = [];
   const tagRegex = /<\/?(\w+)(?:\s[^>]*)?\s*\/?>/g;
   const selfClosingTags = ["br", "hr", "img", "input", "meta", "link", "area", "base", "col", "embed", "param", "source", "track", "wbr"];
@@ -2061,11 +2658,11 @@ function getAgentId4(overrideId) {
   return "01KEQCGJ65YENRA4QBXVN1YFFX";
 }
 function analyzeSpecState(projectRoot) {
-  const specPath = path7.resolve(projectRoot, "tech-spec.md");
-  if (!fs6.existsSync(specPath)) {
+  const specPath = path9.resolve(projectRoot, "tech-spec.md");
+  if (!fs7.existsSync(specPath)) {
     return { status: "MISSING" };
   }
-  const content = fs6.readFileSync(specPath, "utf-8");
+  const content = fs7.readFileSync(specPath, "utf-8");
   const match = content.match(/- \[ \] (.*)/);
   if (match) {
     return { status: "PENDING", nextTask: match[1].trim(), specContent: content };
@@ -2145,12 +2742,12 @@ async function interactiveDeveloperAgent(options = {}) {
   }
   const projectRoot = process.cwd();
   let contextContent = "";
-  const defaultContextPath = path7.resolve(projectRoot, "_sharkrc", "project-context.md");
-  const specificContextPath = options.context ? path7.resolve(projectRoot, options.context) : defaultContextPath;
-  if (fs6.existsSync(specificContextPath)) {
+  const defaultContextPath = path9.resolve(projectRoot, "_sharkrc", "project-context.md");
+  const specificContextPath = options.context ? path9.resolve(projectRoot, options.context) : defaultContextPath;
+  if (fs7.existsSync(specificContextPath)) {
     try {
-      contextContent = fs6.readFileSync(specificContextPath, "utf-8");
-      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path7.relative(projectRoot, specificContextPath))}`);
+      contextContent = fs7.readFileSync(specificContextPath, "utf-8");
+      tui.log.info(`\u{1F4D8} Context loaded from: ${colors.dim(path9.relative(projectRoot, specificContextPath))}`);
     } catch (e) {
       tui.log.warning(`Failed to read context file: ${e}`);
     }
@@ -2297,14 +2894,14 @@ ${previewDiff}
             }
             if (approved) {
               if (filePath) {
-                const targetPath = path7.resolve(projectRoot, filePath);
-                const dir = path7.dirname(targetPath);
-                if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+                const targetPath = path9.resolve(projectRoot, filePath);
+                const dir = path9.dirname(targetPath);
+                if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
                 if (isCreate) {
                   const BOM = "\uFEFF";
                   const contentToWrite = action.content || "";
                   const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-                  fs6.writeFileSync(targetPath, finalContent, { encoding: "utf-8" });
+                  fs7.writeFileSync(targetPath, finalContent, { encoding: "utf-8" });
                   tui.log.success(`\u2705 Created: ${filePath}`);
                   executionResults += `[Action create_file(${filePath})]: Success
 
@@ -2313,7 +2910,7 @@ ${previewDiff}
                   const config = ConfigManager.getInstance().getConfig();
                   const validationEnabled = config.validation?.enablePostSaveValidation ?? true;
                   if (validationEnabled) {
-                    const ext = path7.extname(filePath);
+                    const ext = path9.extname(filePath);
                     if ([".ts", ".tsx"].includes(ext)) {
                       tui.log.info("\u{1F50D} Validating TypeScript...");
                       const validation = await validateTypeScript(filePath);
@@ -2369,7 +2966,7 @@ ${validation.error}
                     const config = ConfigManager.getInstance().getConfig();
                     const validationEnabled = config.validation?.enablePostSaveValidation ?? true;
                     if (validationEnabled) {
-                      const ext = path7.extname(filePath);
+                      const ext = path9.extname(filePath);
                       if ([".ts", ".tsx"].includes(ext)) {
                         tui.log.info("\u{1F50D} Validating TypeScript...");
                         const validation = await validateTypeScript(filePath);
@@ -2449,7 +3046,7 @@ ${result}
 
 `;
                 if (targetPath.endsWith("tech-spec.md")) specUpdated = true;
-                const ext = path7.extname(targetPath);
+                const ext = path9.extname(targetPath);
                 if ([".ts", ".tsx"].includes(ext)) {
                   const validation = await validateTypeScript(targetPath);
                   if (!validation.valid) {
@@ -2471,6 +3068,121 @@ ${validation.error}
 
 `;
             }
+          } else if (action.type.startsWith("ast_")) {
+            const targetPath = action.file_path || action.path || "";
+            tui.log.info(`\u{1F527} [AST] Action: ${colors.bold(action.type)} on ${targetPath}`);
+            if (action.type === "ast_list_structure") {
+              const result = await astListStructure(targetPath);
+              executionResults += `[Action ast_list_structure]:
+${result}
+
+`;
+            } else {
+              let approved = false;
+              if (autoApprovals.files) {
+                approved = true;
+                tui.log.success(`\u26A1 Auto-Approved AST Action: ${action.type}`);
+              } else {
+                const choice = await tui.select({
+                  message: `Execute ${action.type} on ${targetPath}?`,
+                  options: [
+                    { value: "yes", label: "Yes" },
+                    { value: "always", label: "Yes (Auto-Approve ALL Files)" },
+                    { value: "no", label: "No" }
+                  ]
+                });
+                if (choice === "always") {
+                  autoApprovals.files = true;
+                  approved = true;
+                  tui.log.success("\u26A1 FILE ACTIONS Auto-Approval ENABLED for this session.");
+                } else if (choice === "yes") {
+                  approved = true;
+                }
+              }
+              if (approved) {
+                try {
+                  let success = false;
+                  switch (action.type) {
+                    case "ast_add_class":
+                      success = await astAddClass(targetPath, action.class_name || "", action.extends_class || void 0, action.implements_interfaces || void 0);
+                      break;
+                    case "ast_add_method":
+                      success = await astAddMethod(targetPath, action.class_name || "", action.method_code || "");
+                      break;
+                    case "ast_add_property":
+                      success = await astAddProperty(targetPath, action.class_name || "", action.property_code || "");
+                      break;
+                    case "ast_remove_property":
+                      success = await astRemoveProperty(targetPath, action.class_name || "", action.property_name || "");
+                      break;
+                    case "ast_modify_method":
+                      success = await astModifyMethod(targetPath, action.class_name || "", action.method_name || "", action.new_body || "");
+                      break;
+                    case "ast_remove_method":
+                      success = await astRemoveMethod(targetPath, action.class_name || "", action.method_name || "");
+                      break;
+                    case "ast_add_decorator":
+                      success = await astAddDecorator(targetPath, action.class_name || "", action.decorator_code || "");
+                      break;
+                    case "ast_add_interface":
+                      success = await astAddInterface(targetPath, action.interface_code || "");
+                      break;
+                    case "ast_add_type_alias":
+                      success = await astAddTypeAlias(targetPath, action.type_code || "");
+                      break;
+                    case "ast_add_function":
+                      success = await astAddFunction(targetPath, action.function_code || "");
+                      break;
+                    case "ast_remove_function":
+                      success = await astRemoveFunction(targetPath, action.function_name || "");
+                      break;
+                    case "ast_add_import":
+                      success = await astAddImport(targetPath, action.import_statement || "");
+                      break;
+                    case "ast_remove_import":
+                      success = await astRemoveImport(targetPath, action.module_path || "");
+                      break;
+                    case "ast_organize_imports":
+                      success = await astOrganizeImports(targetPath);
+                      break;
+                  }
+                  if (success) {
+                    executionResults += `[Action ${action.type}]: Success
+
+`;
+                    const config = ConfigManager.getInstance().getConfig();
+                    const validationEnabled = config.validation?.enablePostSaveValidation ?? true;
+                    if (validationEnabled) {
+                      const ext = path9.extname(targetPath);
+                      if ([".ts", ".tsx"].includes(ext)) {
+                        const validation = await validateTypeScript(targetPath);
+                        if (!validation.valid) {
+                          executionResults += `
+[TYPESCRIPT VALIDATION FAILED]:
+${validation.error}
+
+`;
+                        } else {
+                          tui.log.success("\u2705 TypeScript OK");
+                        }
+                      }
+                    }
+                  } else {
+                    executionResults += `[Action ${action.type}]: Failed (internal editor returned false).
+
+`;
+                  }
+                } catch (e) {
+                  executionResults += `[Action ${action.type}]: Exception: ${e.message}
+
+`;
+                }
+              } else {
+                executionResults += `[Action ${action.type}]: User Denied.
+
+`;
+              }
+            }
           }
         }
         const previousState = specState;
@@ -2586,8 +3298,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 fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path10 from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 var AGENT_TYPE5 = "qa_agent";
@@ -2656,9 +3368,9 @@ async function runQAAgent(options) {
   }
   let projectContext = "";
   try {
-    const contextPath = path8.join(process.cwd(), "_sharkrc", "project-context.md");
-    if (fs7.existsSync(contextPath)) {
-      projectContext = fs7.readFileSync(contextPath, "utf-8");
+    const contextPath = path10.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) {
@@ -2767,11 +3479,11 @@ ${projectContext}
             break;
           case "create_file":
             if (action.path && action.content) {
-              const fullPath = path8.resolve(process.cwd(), action.path);
+              const fullPath = path10.resolve(process.cwd(), action.path);
               const BOM = "\uFEFF";
               const contentToWrite = action.content;
               const finalContent = contentToWrite.startsWith(BOM) ? contentToWrite : BOM + contentToWrite;
-              fs7.writeFileSync(fullPath, finalContent, { encoding: "utf-8" });
+              fs8.writeFileSync(fullPath, finalContent, { encoding: "utf-8" });
               tui.log.success(`File created: ${action.path}`);
               result = "File created successfully.";
             }