test: enhance app specification and automaker paths tests

- Added comprehensive tests for the `specToXml` function, covering various scenarios including minimal specs, XML escaping, and optional sections.
- Updated tests for `getStructuredSpecPromptInstruction` and `getAppSpecFormatInstruction` to ensure they return valid instructions.
- Refactored automaker paths tests to use `path.join` for cross-platform compatibility, ensuring correct directory paths are generated.

apps/server/tests/unit/lib/app-spec-format.test.ts

@@ -1,57 +1,189 @@
 import { describe, it, expect } from "vitest";
 import {
-  APP_SPEC_XML_FORMAT,
+  specToXml,
+  getStructuredSpecPromptInstruction,
   getAppSpecFormatInstruction,
+  APP_SPEC_XML_FORMAT,
+  type SpecOutput,
 } from "@/lib/app-spec-format.js";
 
 describe("app-spec-format.ts", () => {
-  describe("APP_SPEC_XML_FORMAT", () => {
-    it("should export a non-empty string constant", () => {
-      expect(typeof APP_SPEC_XML_FORMAT).toBe("string");
-      expect(APP_SPEC_XML_FORMAT.length).toBeGreaterThan(0);
+  describe("specToXml", () => {
+    it("should convert minimal spec to XML", () => {
+      const spec: SpecOutput = {
+        project_name: "Test Project",
+        overview: "A test project",
+        technology_stack: ["TypeScript", "Node.js"],
+        core_capabilities: ["Testing", "Development"],
+        implemented_features: [
+          { name: "Feature 1", description: "First feature" },
+        ],
+      };
+
+      const xml = specToXml(spec);
+
+      expect(xml).toContain('<?xml version="1.0" encoding="UTF-8"?>');
+      expect(xml).toContain("<project_specification>");
+      expect(xml).toContain("</project_specification>");
+      expect(xml).toContain("<project_name>Test Project</project_name>");
+      expect(xml).toContain("<technology>TypeScript</technology>");
+      expect(xml).toContain("<capability>Testing</capability>");
     });
 
-    it("should contain XML format documentation", () => {
-      expect(APP_SPEC_XML_FORMAT).toContain("<project_specification>");
-      expect(APP_SPEC_XML_FORMAT).toContain("</project_specification>");
-      expect(APP_SPEC_XML_FORMAT).toContain("<project_name>");
-      expect(APP_SPEC_XML_FORMAT).toContain("<overview>");
-      expect(APP_SPEC_XML_FORMAT).toContain("<technology_stack>");
-      expect(APP_SPEC_XML_FORMAT).toContain("<core_capabilities>");
+    it("should escape XML special characters", () => {
+      const spec: SpecOutput = {
+        project_name: "Test & Project",
+        overview: "Description with <tags>",
+        technology_stack: ["TypeScript"],
+        core_capabilities: ["Cap"],
+        implemented_features: [],
+      };
+
+      const xml = specToXml(spec);
+
+      expect(xml).toContain("Test &amp; Project");
+      expect(xml).toContain("&lt;tags&gt;");
     });
 
-    it("should contain XML escaping instructions", () => {
-      expect(APP_SPEC_XML_FORMAT).toContain("&lt;");
-      expect(APP_SPEC_XML_FORMAT).toContain("&gt;");
-      expect(APP_SPEC_XML_FORMAT).toContain("&amp;");
+    it("should include file_locations when provided", () => {
+      const spec: SpecOutput = {
+        project_name: "Test",
+        overview: "Test",
+        technology_stack: ["TS"],
+        core_capabilities: ["Cap"],
+        implemented_features: [
+          {
+            name: "Feature",
+            description: "Desc",
+            file_locations: ["src/index.ts"],
+          },
+        ],
+      };
+
+      const xml = specToXml(spec);
+
+      expect(xml).toContain("<file_locations>");
+      expect(xml).toContain("<location>src/index.ts</location>");
+    });
+
+    it("should not include file_locations when empty", () => {
+      const spec: SpecOutput = {
+        project_name: "Test",
+        overview: "Test",
+        technology_stack: ["TS"],
+        core_capabilities: ["Cap"],
+        implemented_features: [
+          { name: "Feature", description: "Desc", file_locations: [] },
+        ],
+      };
+
+      const xml = specToXml(spec);
+
+      expect(xml).not.toContain("<file_locations>");
+    });
+
+    it("should include additional_requirements when provided", () => {
+      const spec: SpecOutput = {
+        project_name: "Test",
+        overview: "Test",
+        technology_stack: ["TS"],
+        core_capabilities: ["Cap"],
+        implemented_features: [],
+        additional_requirements: ["Node.js 18+"],
+      };
+
+      const xml = specToXml(spec);
+
+      expect(xml).toContain("<additional_requirements>");
+      expect(xml).toContain("<requirement>Node.js 18+</requirement>");
+    });
+
+    it("should include development_guidelines when provided", () => {
+      const spec: SpecOutput = {
+        project_name: "Test",
+        overview: "Test",
+        technology_stack: ["TS"],
+        core_capabilities: ["Cap"],
+        implemented_features: [],
+        development_guidelines: ["Use ESLint"],
+      };
+
+      const xml = specToXml(spec);
+
+      expect(xml).toContain("<development_guidelines>");
+      expect(xml).toContain("<guideline>Use ESLint</guideline>");
+    });
+
+    it("should include implementation_roadmap when provided", () => {
+      const spec: SpecOutput = {
+        project_name: "Test",
+        overview: "Test",
+        technology_stack: ["TS"],
+        core_capabilities: ["Cap"],
+        implemented_features: [],
+        implementation_roadmap: [
+          { phase: "Phase 1", status: "completed", description: "Setup" },
+        ],
+      };
+
+      const xml = specToXml(spec);
+
+      expect(xml).toContain("<implementation_roadmap>");
+      expect(xml).toContain("<status>completed</status>");
+    });
+
+    it("should not include optional sections when empty", () => {
+      const spec: SpecOutput = {
+        project_name: "Test",
+        overview: "Test",
+        technology_stack: ["TS"],
+        core_capabilities: ["Cap"],
+        implemented_features: [],
+        additional_requirements: [],
+        development_guidelines: [],
+        implementation_roadmap: [],
+      };
+
+      const xml = specToXml(spec);
+
+      expect(xml).not.toContain("<additional_requirements>");
+      expect(xml).not.toContain("<development_guidelines>");
+      expect(xml).not.toContain("<implementation_roadmap>");
+    });
+  });
+
+  describe("getStructuredSpecPromptInstruction", () => {
+    it("should return non-empty prompt instruction", () => {
+      const instruction = getStructuredSpecPromptInstruction();
+      expect(instruction).toBeTruthy();
+      expect(instruction.length).toBeGreaterThan(100);
+    });
+
+    it("should mention required fields", () => {
+      const instruction = getStructuredSpecPromptInstruction();
+      expect(instruction).toContain("project_name");
+      expect(instruction).toContain("overview");
+      expect(instruction).toContain("technology_stack");
     });
   });
 
   describe("getAppSpecFormatInstruction", () => {
-    it("should return a string containing the XML format", () => {
+    it("should return non-empty format instruction", () => {
       const instruction = getAppSpecFormatInstruction();
-      expect(typeof instruction).toBe("string");
-      expect(instruction).toContain(APP_SPEC_XML_FORMAT);
+      expect(instruction).toBeTruthy();
+      expect(instruction.length).toBeGreaterThan(100);
     });
 
-    it("should contain critical formatting requirements", () => {
+    it("should include critical formatting requirements", () => {
       const instruction = getAppSpecFormatInstruction();
       expect(instruction).toContain("CRITICAL FORMATTING REQUIREMENTS");
-      expect(instruction).toContain("<project_specification>");
-      expect(instruction).toContain("</project_specification>");
     });
+  });
 
-    it("should contain verification instructions", () => {
-      const instruction = getAppSpecFormatInstruction();
-      expect(instruction).toContain("VERIFICATION");
-      expect(instruction).toContain("exactly one root XML element");
-    });
-
-    it("should instruct not to use markdown", () => {
-      const instruction = getAppSpecFormatInstruction();
-      expect(instruction).toContain("Do NOT use markdown");
-      expect(instruction).toContain("no # headers");
-      expect(instruction).toContain("no **bold**");
+  describe("APP_SPEC_XML_FORMAT", () => {
+    it("should contain valid XML template structure", () => {
+      expect(APP_SPEC_XML_FORMAT).toContain("<project_specification>");
+      expect(APP_SPEC_XML_FORMAT).toContain("</project_specification>");
     });
   });
 });