feat: add line numbers to PTC type errors

- Move muxTypes after agent code in typeValidator so error positions match
- Return TypeValidationError objects with message, line, column instead of strings
- Update staticAnalysis to propagate line/column from type errors
- Add tests for line number reporting in code_execution.test.ts and typeValidator.test.ts

Author: ethanndickson

src/node/services/ptc/staticAnalysis.ts

@@ -314,10 +314,12 @@ export async function analyzeCode(code: string, muxTypes?: string): Promise<Anal
   // 4. TypeScript type validation (if muxTypes provided)
   if (muxTypes) {
     const typeResult = validateTypes(code, muxTypes);
-    for (const message of typeResult.errors) {
+    for (const typeError of typeResult.errors) {
       errors.push({
         type: "type_error",
-        message,
+        message: typeError.message,
+        line: typeError.line,
+        column: typeError.column,
       });
     }
   }

src/node/services/ptc/typeValidator.test.ts

@@ -71,7 +71,9 @@ describe("validateTypes", () => {
     );
     expect(result.valid).toBe(false);
     // Error should mention 'path' doesn't exist or 'filePath' is missing
-    expect(result.errors.some((e) => e.includes("path") || e.includes("filePath"))).toBe(true);
+    expect(result.errors.some((e) => e.message.includes("path") || e.message.includes("filePath"))).toBe(
+      true
+    );
   });
 
   test("catches missing required property", () => {
@@ -94,7 +96,9 @@ describe("validateTypes", () => {
       muxTypes
     );
     expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.includes("number") || e.includes("string"))).toBe(true);
+    expect(result.errors.some((e) => e.message.includes("number") || e.message.includes("string"))).toBe(
+      true
+    );
   });
 
   test("catches calling non-existent tool", () => {
@@ -105,7 +109,21 @@ describe("validateTypes", () => {
       muxTypes
     );
     expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.includes("nonexistent_tool"))).toBe(true);
+    expect(result.errors.some((e) => e.message.includes("nonexistent_tool"))).toBe(true);
+  });
+
+  test("returns line numbers for type errors", () => {
+    const result = validateTypes(
+      `const x = 1;
+const y = 2;
+mux.file_read({ path: "test.txt" });`,
+      muxTypes
+    );
+    expect(result.valid).toBe(false);
+    // Error should be on line 3 (the mux.file_read call)
+    const errorWithLine = result.errors.find((e) => e.line !== undefined);
+    expect(errorWithLine).toBeDefined();
+    expect(errorWithLine!.line).toBe(3);
   });
 
   test("allows dynamic property access (no strict checking on unknown keys)", () => {

src/node/services/ptc/typeValidator.ts

@@ -11,9 +11,15 @@
 
 import ts from "typescript";
 
+export interface TypeValidationError {
+  message: string;
+  line?: number;
+  column?: number;
+}
+
 export interface TypeValidationResult {
   valid: boolean;
-  errors: string[];
+  errors: TypeValidationError[];
 }
 
 /**
@@ -26,11 +32,12 @@ export interface TypeValidationResult {
 export function validateTypes(code: string, muxTypes: string): TypeValidationResult {
   // Wrap code in function to allow return statements (matches runtime behavior)
   // Note: We don't use async because Asyncify makes mux.* calls appear synchronous
-  const wrappedCode = `${muxTypes}
-
-function __agent__() {
-${code}
+  // Types go AFTER code so error line numbers match agent's code directly
+  const wrapperPrefix = "function __agent__() {\n";
+  const wrappedCode = `${wrapperPrefix}${code}
 }
+
+${muxTypes}
 `;
 
   const compilerOptions: ts.CompilerOptions = {
@@ -64,11 +71,25 @@ ${code}
 
   // Filter to errors in our code only (not lib files)
   // Also filter console redeclaration warning (our minimal console conflicts with lib.dom)
-  const errors = diagnostics
+  const errors: TypeValidationError[] = diagnostics
     .filter((d) => d.category === ts.DiagnosticCategory.Error)
     .filter((d) => !d.file || d.file.fileName === "agent.ts")
     .filter((d) => !ts.flattenDiagnosticMessageText(d.messageText, "").includes("console"))
-    .map((d) => ts.flattenDiagnosticMessageText(d.messageText, " "));
+    .map((d) => {
+      const message = ts.flattenDiagnosticMessageText(d.messageText, " ");
+      // Extract line number if available, adjusting for wrapper prefix
+      if (d.file && d.start !== undefined) {
+        const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
+        // Line is 0-indexed; wrapper adds 1 line ("function __agent__() {\n")
+        // Only report line if it's in the agent's code (not in muxTypes after)
+        const agentCodeLines = code.split("\n").length;
+        const adjustedLine = line; // line 1 in file = line 0 (0-indexed) = agent line 1
+        if (adjustedLine >= 1 && adjustedLine <= agentCodeLines) {
+          return { message, line: adjustedLine, column: character + 1 };
+        }
+      }
+      return { message };
+    });
 
   return { valid: errors.length === 0, errors };
 }

src/node/services/tools/code_execution.test.ts

@@ -140,6 +140,18 @@ describe("createCodeExecutionTool", () => {
       expect(result.error).toContain("process");
     });
 
+    it("includes line numbers for unavailable globals", async () => {
+      const tool = await createCodeExecutionTool(runtimeFactory, new ToolBridge({}));
+
+      const result = (await tool.execute!(
+        { code: "const x = 1;\nconst y = 2;\nconst env = process.env" }, // process on line 3
+        mockToolCallOptions
+      )) as PTCExecutionResult;
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("(line 3)");
+    });
+
     it("rejects code using require()", async () => {
       const tool = await createCodeExecutionTool(runtimeFactory, new ToolBridge({}));
 
@@ -152,6 +164,39 @@ describe("createCodeExecutionTool", () => {
       expect(result.error).toContain("Code analysis failed");
       expect(result.error).toContain("require");
     });
+
+    it("includes line numbers for type errors", async () => {
+      const mockTools: Record<string, Tool> = {
+        bash: createMockTool("bash", z.object({ script: z.string() })),
+      };
+      const tool = await createCodeExecutionTool(runtimeFactory, new ToolBridge(mockTools));
+
+      const result = (await tool.execute!(
+        { code: "const x = 1;\nconst result = mux.bash({ scriptz: 'ls' });" }, // typo on line 2
+        mockToolCallOptions
+      )) as PTCExecutionResult;
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Code analysis failed");
+      expect(result.error).toContain("scriptz");
+      expect(result.error).toContain("(line 2)");
+    });
+
+    it("includes line numbers for calling non-existent tools", async () => {
+      const mockTools: Record<string, Tool> = {
+        bash: createMockTool("bash", z.object({ script: z.string() })),
+      };
+      const tool = await createCodeExecutionTool(runtimeFactory, new ToolBridge(mockTools));
+
+      const result = (await tool.execute!(
+        { code: "const x = 1;\nconst y = 2;\nmux.nonexistent({ arg: 1 });" }, // line 3
+        mockToolCallOptions
+      )) as PTCExecutionResult;
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Code analysis failed");
+      expect(result.error).toContain("(line 3)");
+    });
   });
 
   describe("code execution", () => {