466 lines
20 KiB
JavaScript
466 lines
20 KiB
JavaScript
import { describe, it, expect } from "vitest";
|
|
import { buildArchitectureReviewPrompt } from "../../src/prompts/architecture-review.js";
|
|
|
|
describe("buildArchitectureReviewPrompt", () => {
|
|
// --- Basic output contract ---
|
|
|
|
it("returns a non-empty string given question-only input", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Should we use a managed vector database?" });
|
|
expect(typeof result).toBe("string");
|
|
expect(result.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("is deterministic — same input always produces the same output", () => {
|
|
const a = buildArchitectureReviewPrompt({ question: "Should we use a managed vector database?" });
|
|
const b = buildArchitectureReviewPrompt({ question: "Should we use a managed vector database?" });
|
|
expect(a).toBe(b);
|
|
});
|
|
|
|
// --- Explicit separator ---
|
|
|
|
it("uses an explicit \\n---\\n separator between base and tool sections", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toContain("\n\n---\n\n");
|
|
});
|
|
|
|
it("contains exactly one separator (two-part prompt)", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
const parts = result.split("\n\n---\n\n");
|
|
expect(parts.length).toBe(2);
|
|
});
|
|
|
|
// --- Composition with base prompt ---
|
|
|
|
it("includes the base system prompt content", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toContain("second-opinion assistant");
|
|
expect(result).toContain("Claude Code");
|
|
expect(result).toContain("not responsible for editing files");
|
|
});
|
|
|
|
// --- Architecture advisor role instructions ---
|
|
|
|
it("contains architecture advisor role instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toContain("architecture advisor");
|
|
});
|
|
|
|
it("instructs Claude Code as the implementation agent", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toContain("Claude Code will implement your suggestions");
|
|
});
|
|
|
|
it("instructs ChatGPT that you do not implement anything yourself", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toContain("you do not implement anything yourself");
|
|
});
|
|
|
|
it("states ChatGPT is acting only as an architecture advisor", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/acting\s+only\s+as\s+an?\s+architecture\s+advisor/i);
|
|
});
|
|
|
|
// --- Guard rails ---
|
|
|
|
it("states Claude Code remains the implementation agent", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toContain("Claude Code remains the implementation agent");
|
|
});
|
|
|
|
it("instructs ChatGPT to use only supplied context and files", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/use\s+only\s+the?\s+supplied\s+context/i);
|
|
});
|
|
|
|
it("instructs ChatGPT not to assume repository-wide context", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/not\s+assume\s+repository-wide\s+context/i);
|
|
});
|
|
|
|
it("instructs to prefer simple, incremental architecture", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/prefer\s+simple.*incremental.*architecture/i);
|
|
});
|
|
|
|
it("instructs to avoid large rewrites unless justified", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/avoid\s+large\s+rewrites.*unless.*justified/i);
|
|
});
|
|
|
|
// --- Review dimensions (10) ---
|
|
|
|
it("contains Simplicity dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toContain("simplicity");
|
|
});
|
|
|
|
it("contains Maintainability dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toContain("maintainability");
|
|
});
|
|
|
|
it("contains Security dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/security/i);
|
|
});
|
|
|
|
it("contains Scalability dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toContain("scalability");
|
|
});
|
|
|
|
it("contains Operational burden dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toContain("operational burden");
|
|
});
|
|
|
|
it("contains Vendor lock-in dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toContain("vendor lock-in");
|
|
});
|
|
|
|
it("contains Local-first / self-hosted fit dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toMatch(/local-?first.*self-?hosted\s+fit|self-?hosted.*local-?first/i);
|
|
});
|
|
|
|
it("contains Integration risk dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toContain("integration risk");
|
|
});
|
|
|
|
it("contains Migration risk dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toContain("migration risk");
|
|
});
|
|
|
|
it("contains Appropriateness for current project stage dimension instruction", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/appropriateness.*project\s+stage|current\s+project\s+stage/i);
|
|
});
|
|
|
|
// --- Response structure (8 sections) ---
|
|
|
|
it("requests Summary section in response structure", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/summary/i);
|
|
});
|
|
|
|
it("requests Recommendation section in response structure", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/recommendation/i);
|
|
});
|
|
|
|
it("requests Trade-offs section in response structure", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/trade-?offs?/i);
|
|
});
|
|
|
|
it("requests Risks section in response structure", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/risks/i);
|
|
});
|
|
|
|
it("requests Future Extension Paths section in response structure", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/future\s+extension\s+paths/i);
|
|
});
|
|
|
|
it("requests Simpler Alternatives section in response structure", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).toContain("simpler alternatives");
|
|
});
|
|
|
|
it("requests Implementation Notes section in response structure", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/implementation\s+notes/i);
|
|
});
|
|
|
|
it("requests Decision Confidence section in response structure", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).toMatch(/decision\s+confidence/i);
|
|
});
|
|
|
|
// --- Question field ---
|
|
|
|
it("appends the input question verbatim in the task section", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Should we migrate to S3?" });
|
|
expect(result).toContain("Question: Should we migrate to S3?");
|
|
});
|
|
|
|
// --- Optional fields appended correctly (with question) ---
|
|
|
|
it("appends Context when context is provided", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we use a managed vector DB?",
|
|
context: "Current stack uses PostgreSQL with pgvector for search.",
|
|
});
|
|
expect(result).toContain("Context: Current stack uses PostgreSQL with pgvector for search.");
|
|
});
|
|
|
|
it("does NOT append Context section when context is empty", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test", context: "" });
|
|
expect(result).not.toContain("Context:");
|
|
});
|
|
|
|
it("appends Constraints list when constraints are provided", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we use a managed vector DB?",
|
|
constraints: ["Must be self-hostable", "Budget under $100/mo"],
|
|
});
|
|
expect(result).toContain("Constraints:");
|
|
expect(result).toContain("- Must be self-hostable");
|
|
expect(result).toContain("- Budget under $100/mo");
|
|
});
|
|
|
|
it("does NOT append Constraints section when constraints array is empty", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test", constraints: [] });
|
|
expect(result).not.toContain("Constraints:");
|
|
});
|
|
|
|
it("appends Expected output when expectedOutput is provided", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we use a managed vector DB?",
|
|
expectedOutput: "A trade-off analysis comparing options.",
|
|
});
|
|
expect(result).toContain(
|
|
"Expected output: A trade-off analysis comparing options."
|
|
);
|
|
});
|
|
|
|
it("does NOT append Expected output section when expectedOutput is omitted", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).not.toContain("Expected output:");
|
|
});
|
|
|
|
it("does NOT append Expected output section when expectedOutput is empty", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test", expectedOutput: "" });
|
|
expect(result).not.toContain("Expected output:");
|
|
});
|
|
|
|
it("appends all optional fields alongside each other", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we migrate to S3?",
|
|
context: "Current stack uses local disk with Express.",
|
|
constraints: ["Must be deployable without Kubernetes", "Budget under $100/mo"],
|
|
expectedOutput: "A comparison of S3, MinIO, and shared NFS.",
|
|
projectSummary: "Internal document management system for a 50-person team.",
|
|
taskSummary: "Migrating from local filesystem to scalable object storage.",
|
|
});
|
|
expect(result).toContain("Question: Should we migrate to S3?");
|
|
expect(result).toContain("Context: Current stack uses local disk with Express.");
|
|
expect(result).toContain("Constraints:");
|
|
expect(result).toContain("- Must be deployable without Kubernetes");
|
|
expect(result).toContain("- Budget under $100/mo");
|
|
expect(result).toContain("Expected output: A comparison of S3, MinIO, and shared NFS.");
|
|
expect(result).toContain(
|
|
"Project summary: Internal document management system for a 50-person team."
|
|
);
|
|
expect(result).toContain(
|
|
"Task summary: Migrating from local filesystem to scalable object storage."
|
|
);
|
|
});
|
|
|
|
it("does NOT append Project summary when projectSummary is omitted", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).not.toContain("Project summary:");
|
|
});
|
|
|
|
it("does NOT append Task summary when taskSummary is omitted", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).not.toContain("Task summary:");
|
|
});
|
|
|
|
// --- relevantFiles (present) ---
|
|
|
|
it("includes file section header when relevantFiles is provided", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we migrate to S3?",
|
|
relevantFiles: [
|
|
{ path: "src/storage/local.js", content: "fs.writeFileSync(path, data);" },
|
|
],
|
|
});
|
|
expect(result).toContain("Relevant files:");
|
|
});
|
|
|
|
it("includes file path, language, and content when relevantFiles has language", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we migrate to S3?",
|
|
relevantFiles: [
|
|
{ path: "src/storage/local.js", language: "javascript", content: "fs.writeFileSync(path, data);" },
|
|
],
|
|
});
|
|
expect(result).toContain("File: src/storage/local.js");
|
|
expect(result).toContain("Language: javascript");
|
|
expect(result).toContain("fs.writeFileSync(path, data);");
|
|
});
|
|
|
|
it("includes file content without language header when language is omitted", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we migrate to S3?",
|
|
relevantFiles: [
|
|
{ path: "src/storage/local.js", content: "fs.writeFileSync(path, data);" },
|
|
],
|
|
});
|
|
expect(result).toContain("File: src/storage/local.js");
|
|
expect(result).not.toContain("Language:");
|
|
expect(result).toContain("fs.writeFileSync(path, data);");
|
|
});
|
|
|
|
it("includes multiple files when relevantFiles has multiple entries", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we migrate to S3?",
|
|
relevantFiles: [
|
|
{ path: "src/storage/local.js", language: "javascript", content: "fs.writeFileSync(path, data);" },
|
|
{ path: "src/middleware/upload.js", language: "javascript", content: "app.post('/upload', handler);" },
|
|
],
|
|
});
|
|
expect(result).toContain("File: src/storage/local.js");
|
|
expect(result).toContain("File: src/middleware/upload.js");
|
|
expect(result).toContain("fs.writeFileSync(path, data);");
|
|
expect(result).toContain("app.post('/upload', handler);");
|
|
});
|
|
|
|
// --- relevantFiles (absent/empty) ---
|
|
|
|
it("does NOT include Relevant files section when relevantFiles is omitted", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).not.toContain("Relevant files:");
|
|
});
|
|
|
|
it("does NOT include Relevant files section when relevantFiles is empty array", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test", relevantFiles: [] });
|
|
expect(result).not.toContain("Relevant files:");
|
|
});
|
|
|
|
// --- Tool-specific guard ---
|
|
|
|
it("does NOT contain debug_issue specific content", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).not.toContain("Likely Causes");
|
|
expect(result).not.toContain("Fast Checks");
|
|
});
|
|
|
|
it("does NOT contain review_plan specific content", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result).not.toContain("missing steps");
|
|
expect(result).not.toContain("scope creep");
|
|
});
|
|
|
|
it("does NOT contain review_code specific content", () => {
|
|
const result = buildArchitectureReviewPrompt({ question: "Test" });
|
|
expect(result.toLowerCase()).not.toContain("issues by severity");
|
|
expect(result.toLowerCase()).not.toContain("suggested fixes");
|
|
});
|
|
|
|
// --- Input validation ---
|
|
|
|
it("throws TypeError when input is missing, null, or undefined", () => {
|
|
expect(() => buildArchitectureReviewPrompt()).toThrow(TypeError);
|
|
expect(() => buildArchitectureReviewPrompt(null)).toThrow(TypeError);
|
|
expect(() => buildArchitectureReviewPrompt(undefined)).toThrow(TypeError);
|
|
});
|
|
|
|
it("throws TypeError when question is missing", () => {
|
|
expect(() => buildArchitectureReviewPrompt({ context: "something" })).toThrow(TypeError);
|
|
});
|
|
|
|
it("throws TypeError when question is empty", () => {
|
|
expect(() => buildArchitectureReviewPrompt({ question: "" })).toThrow(TypeError);
|
|
});
|
|
|
|
// --- Full integration test ---
|
|
|
|
it("returns a well-formed two-part prompt with all fields and relevantFiles", () => {
|
|
const result = buildArchitectureReviewPrompt({
|
|
question: "Should we migrate our file storage from local filesystem to an object store?",
|
|
context: "Current system stores uploads on the application server's disk. We're getting disk space alerts and need multi-server support.",
|
|
constraints: ["Must be deployable without Kubernetes", "Cost must not exceed current $50/mo by more than 50%"],
|
|
expectedOutput: "A comparison of S3, MinIO, and shared NFS with trade-off analysis.",
|
|
projectSummary: "Internal document management system for a mid-sized company.",
|
|
taskSummary: "Migrating from local disk storage to a scalable file storage solution.",
|
|
relevantFiles: [
|
|
{
|
|
path: "src/storage/local-filesystem.js",
|
|
language: "javascript",
|
|
content: `const fs = require('fs');\n\nfunction saveFile(name, data) {\n fs.writeFileSync(\`./uploads/\${name}\`, data);\n}`,
|
|
},
|
|
{
|
|
path: "src/middleware/upload.js",
|
|
content: `app.post('/upload', upload.single('file'), (req, res) => { ... });`,
|
|
},
|
|
],
|
|
});
|
|
|
|
// Base section present
|
|
expect(result).toContain("second-opinion assistant");
|
|
expect(result).toContain("Rules:");
|
|
|
|
// Explicit separator — exactly one
|
|
const parts = result.split("\n\n---\n\n");
|
|
expect(parts.length).toBe(2);
|
|
|
|
// Tool-specific section present (second part)
|
|
const toolSection = parts[1];
|
|
expect(toolSection).toContain("architecture advisor");
|
|
expect(toolSection).toContain("Claude Code remains the implementation agent");
|
|
expect(toolSection).toMatch(/use\s+only\s+the?\s+supplied\s+context/i);
|
|
|
|
// Guard rails present
|
|
expect(toolSection).toMatch(/prefer\s+simple.*incremental.*architecture/i);
|
|
expect(toolSection).toMatch(/avoid\s+large\s+rewrites.*unless.*justified/i);
|
|
|
|
// All 10 review dimensions
|
|
expect(toolSection.toLowerCase()).toContain("simplicity");
|
|
expect(toolSection.toLowerCase()).toContain("maintainability");
|
|
expect(toolSection).toMatch(/security/i);
|
|
expect(toolSection.toLowerCase()).toContain("scalability");
|
|
expect(toolSection.toLowerCase()).toContain("operational burden");
|
|
expect(toolSection.toLowerCase()).toContain("vendor lock-in");
|
|
expect(toolSection.toLowerCase()).toMatch(/local-?first.*self-?hosted\s+fit|self-?hosted.*local-?first/i);
|
|
expect(toolSection.toLowerCase()).toContain("integration risk");
|
|
expect(toolSection.toLowerCase()).toContain("migration risk");
|
|
expect(toolSection).toMatch(/appropriateness.*project\s+stage|current\s+project\s+stage/i);
|
|
|
|
// All 8 response structure sections
|
|
expect(toolSection).toMatch(/summary/i);
|
|
expect(toolSection).toMatch(/recommendation/i);
|
|
expect(toolSection).toMatch(/trade-?offs?/i);
|
|
expect(toolSection).toMatch(/risks/i);
|
|
expect(toolSection).toMatch(/future\s+extension\s+paths/i);
|
|
expect(toolSection.toLowerCase()).toContain("simpler alternatives");
|
|
expect(toolSection).toMatch(/implementation\s+notes/i);
|
|
expect(toolSection).toMatch(/decision\s+confidence/i);
|
|
|
|
// All fields present verbatim
|
|
expect(result).toContain("Question: Should we migrate our file storage from local filesystem to an object store?");
|
|
expect(result).toContain("Context: Current system stores uploads on the application server's disk. We're getting disk space alerts and need multi-server support.");
|
|
expect(result).toContain("Constraints:");
|
|
expect(result).toContain("- Must be deployable without Kubernetes");
|
|
expect(result).toContain("- Cost must not exceed current $50/mo by more than 50%");
|
|
expect(result).toContain(
|
|
"Expected output: A comparison of S3, MinIO, and shared NFS with trade-off analysis."
|
|
);
|
|
expect(result).toContain(
|
|
"Project summary: Internal document management system for a mid-sized company."
|
|
);
|
|
expect(result).toContain(
|
|
"Task summary: Migrating from local disk storage to a scalable file storage solution."
|
|
);
|
|
|
|
// Relevant files present
|
|
expect(toolSection).toContain("Relevant files:");
|
|
expect(toolSection).toContain("File: src/storage/local-filesystem.js");
|
|
expect(toolSection).toContain("Language: javascript");
|
|
expect(toolSection).toContain("fs.writeFileSync");
|
|
expect(toolSection).toContain("File: src/middleware/upload.js");
|
|
|
|
// Does not contain other tool content
|
|
expect(toolSection).not.toContain("Likely Causes");
|
|
expect(toolSection).not.toContain("Fast Checks");
|
|
expect(toolSection).not.toContain("missing steps");
|
|
expect(toolSection).not.toContain("scope creep");
|
|
expect(toolSection.toLowerCase()).not.toContain("issues by severity");
|
|
});
|
|
});
|