@stackweld/core 0.2.0

package/src/__tests__/rules-engine.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from "vitest";
+import { RulesEngine } from "../engine/rules-engine.js";
+import type { StackTechnology, Technology } from "../types/index.js";
+
+const mockTechs: Technology[] = [
+  {
+    id: "nodejs",
+    name: "Node.js",
+    category: "runtime",
+    description: "",
+    website: "",
+    versions: [{ version: "22" }],
+    defaultVersion: "22",
+    defaultPort: 3000,
+    requires: [],
+    incompatibleWith: [],
+    suggestedWith: ["typescript"],
+    envVars: {},
+    configFiles: [],
+    lastVerified: "2026-03-22",
+    tags: [],
+  },
+  {
+    id: "nextjs",
+    name: "Next.js",
+    category: "frontend",
+    description: "",
+    website: "",
+    versions: [{ version: "15" }],
+    defaultVersion: "15",
+    defaultPort: 3000,
+    requires: ["nodejs", "react"],
+    incompatibleWith: ["nuxt"],
+    suggestedWith: ["typescript", "tailwindcss"],
+    envVars: {},
+    configFiles: [],
+    lastVerified: "2026-03-22",
+    tags: [],
+  },
+  {
+    id: "react",
+    name: "React",
+    category: "frontend",
+    description: "",
+    website: "",
+    versions: [{ version: "19" }],
+    defaultVersion: "19",
+    defaultPort: 3000,
+    requires: ["nodejs"],
+    incompatibleWith: [],
+    suggestedWith: [],
+    envVars: {},
+    configFiles: [],
+    lastVerified: "2026-03-22",
+    tags: [],
+  },
+  {
+    id: "nuxt",
+    name: "Nuxt",
+    category: "frontend",
+    description: "",
+    website: "",
+    versions: [{ version: "3" }],
+    defaultVersion: "3",
+    defaultPort: 3000,
+    requires: ["nodejs"],
+    incompatibleWith: ["nextjs"],
+    suggestedWith: [],
+    envVars: {},
+    configFiles: [],
+    lastVerified: "2026-03-22",
+    tags: [],
+  },
+  {
+    id: "postgresql",
+    name: "PostgreSQL",
+    category: "database",
+    description: "",
+    website: "",
+    versions: [{ version: "17" }],
+    defaultVersion: "17",
+    defaultPort: 5432,
+    requires: [],
+    incompatibleWith: [],
+    suggestedWith: [],
+    envVars: {},
+    configFiles: [],
+    lastVerified: "2026-03-22",
+    tags: [],
+  },
+  {
+    id: "typescript",
+    name: "TypeScript",
+    category: "devops",
+    description: "",
+    website: "",
+    versions: [{ version: "5" }],
+    defaultVersion: "5",
+    requires: [],
+    incompatibleWith: [],
+    suggestedWith: [],
+    envVars: {},
+    configFiles: [],
+    lastVerified: "2026-03-22",
+    tags: [],
+  },
+];
+
+describe("RulesEngine", () => {
+  const engine = new RulesEngine(mockTechs);
+
+  it("validates a simple valid stack", () => {
+    const selected: StackTechnology[] = [
+      { technologyId: "nodejs", version: "22" },
+      { technologyId: "postgresql", version: "17" },
+    ];
+    const result = engine.validate(selected);
+    expect(result.valid).toBe(true);
+    expect(result.issues.filter((i) => i.severity === "error")).toHaveLength(0);
+  });
+
+  it("auto-resolves missing dependencies", () => {
+    const selected: StackTechnology[] = [{ technologyId: "nextjs", version: "15" }];
+    const result = engine.validate(selected);
+    expect(result.resolvedDependencies).toContain("nodejs");
+    expect(result.resolvedDependencies).toContain("react");
+    expect(result.issues.some((i) => i.code === "AUTO_DEPENDENCY")).toBe(true);
+  });
+
+  it("detects incompatible technologies", () => {
+    const selected: StackTechnology[] = [
+      { technologyId: "nodejs", version: "22" },
+      { technologyId: "nextjs", version: "15" },
+      { technologyId: "nuxt", version: "3" },
+    ];
+    const result = engine.validate(selected);
+    expect(result.valid).toBe(false);
+    expect(result.issues.some((i) => i.code === "INCOMPATIBLE")).toBe(true);
+  });
+
+  it("detects and resolves port conflicts", () => {
+    const selected: StackTechnology[] = [
+      { technologyId: "nodejs", version: "22" },
+      { technologyId: "react", version: "19" },
+      { technologyId: "nextjs", version: "15" },
+    ];
+    const result = engine.validate(selected);
+    const ports = Object.values(result.portAssignments);
+    const uniquePorts = new Set(ports);
+    expect(ports.length).toBe(uniquePorts.size); // No duplicates
+  });
+
+  it("detects unknown technologies", () => {
+    const selected: StackTechnology[] = [{ technologyId: "doesnotexist", version: "1" }];
+    const result = engine.validate(selected);
+    expect(result.valid).toBe(false);
+    expect(result.issues.some((i) => i.code === "UNKNOWN_TECHNOLOGY")).toBe(true);
+  });
+
+  it("returns suggestions for selected stack", () => {
+    const suggestions = engine.getSuggestions(["nodejs"]);
+    expect(suggestions.some((s) => s.id === "typescript")).toBe(true);
+  });
+
+  it("gets technologies by category", () => {
+    const frontends = engine.getByCategory("frontend");
+    expect(frontends.length).toBeGreaterThan(0);
+    expect(frontends.every((t) => t.category === "frontend")).toBe(true);
+  });
+});

package/src/__tests__/scaffold-orchestrator.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it } from "vitest";
+import { ScaffoldOrchestrator } from "../engine/scaffold-orchestrator.js";
+import type { StackDefinition, Technology } from "../types/index.js";
+
+const mockTechs: Technology[] = [
+  {
+    id: "nodejs",
+    name: "Node.js",
+    category: "runtime",
+    description: "JavaScript runtime",
+    website: "https://nodejs.org",
+    versions: [{ version: "22" }],
+    defaultVersion: "22",
+    defaultPort: 3000,
+    requires: [],
+    incompatibleWith: [],
+    suggestedWith: [],
+    envVars: { NODE_ENV: "development", PORT: "3000" },
+    configFiles: ["package.json"],
+    lastVerified: "2026-03-22",
+    tags: ["nodejs"],
+  },
+  {
+    id: "postgresql",
+    name: "PostgreSQL",
+    category: "database",
+    description: "Relational database",
+    website: "https://postgresql.org",
+    versions: [{ version: "17" }],
+    defaultVersion: "17",
+    defaultPort: 5432,
+    requires: [],
+    incompatibleWith: [],
+    suggestedWith: [],
+    dockerImage: "postgres:17",
+    healthCheck: {
+      command: "pg_isready -U postgres",
+      interval: "5s",
+      timeout: "5s",
+      retries: 5,
+    },
+    envVars: {
+      POSTGRES_USER: "postgres",
+      POSTGRES_PASSWORD: "postgres",
+      POSTGRES_DB: "app",
+    },
+    configFiles: [],
+    lastVerified: "2026-03-22",
+    tags: ["postgresql"],
+  },
+  {
+    id: "redis",
+    name: "Redis",
+    category: "database",
+    description: "In-memory store",
+    website: "https://redis.io",
+    versions: [{ version: "7" }],
+    defaultVersion: "7",
+    defaultPort: 6379,
+    requires: [],
+    incompatibleWith: [],
+    suggestedWith: [],
+    dockerImage: "redis:7-alpine",
+    healthCheck: {
+      command: "redis-cli ping",
+      interval: "5s",
+      timeout: "5s",
+      retries: 5,
+    },
+    envVars: { REDIS_URL: "redis://localhost:6379/0" },
+    configFiles: [],
+    lastVerified: "2026-03-22",
+    tags: ["redis"],
+  },
+];
+
+const mockStack: StackDefinition = {
+  id: "test-stack",
+  name: "Test Stack",
+  description: "A test stack",
+  profile: "standard",
+  technologies: [
+    { technologyId: "nodejs", version: "22", port: 3000 },
+    { technologyId: "postgresql", version: "17", port: 5432 },
+    { technologyId: "redis", version: "7", port: 6379 },
+  ],
+  createdAt: "2026-03-22T00:00:00Z",
+  updatedAt: "2026-03-22T00:00:00Z",
+  version: 1,
+  tags: ["test"],
+};
+
+describe("ScaffoldOrchestrator", () => {
+  const orchestrator = new ScaffoldOrchestrator(mockTechs);
+
+  it("generates all scaffold files", () => {
+    const output = orchestrator.generate(mockStack);
+    expect(output.dockerCompose).not.toBeNull();
+    expect(output.envExample).toBeTruthy();
+    expect(output.readme).toBeTruthy();
+    expect(output.gitignore).toBeTruthy();
+    expect(output.devcontainer).toBeTruthy();
+  });
+
+  it("generates docker-compose with correct services", () => {
+    const compose = orchestrator.generateDockerCompose(mockStack, mockTechs);
+    expect(compose).toContain("postgresql:");
+    expect(compose).toContain("image: postgres:17");
+    expect(compose).toContain("redis:");
+    expect(compose).toContain("image: redis:7-alpine");
+    expect(compose).toContain("5432:5432");
+    expect(compose).toContain("6379:6379");
+    expect(compose).toContain("pg_isready");
+    expect(compose).toContain("redis-cli ping");
+    expect(compose).toContain("volumes:");
+    // Should NOT include nodejs (no docker image)
+    expect(compose).not.toContain("nodejs:");
+  });
+
+  it("generates .env.example with all env vars", () => {
+    const env = orchestrator.generateEnvExample(mockStack, mockTechs);
+    expect(env).toContain("NODE_ENV=development");
+    expect(env).toContain("POSTGRES_USER=postgres");
+    expect(env).toContain("REDIS_URL=redis://localhost:6379/0");
+  });
+
+  it("generates README with stack table", () => {
+    const readme = orchestrator.generateReadme(mockStack, mockTechs);
+    expect(readme).toContain("# Test Stack");
+    expect(readme).toContain("Node.js");
+    expect(readme).toContain("PostgreSQL");
+    expect(readme).toContain("docker compose up");
+  });
+
+  it("generates .gitignore with relevant patterns", () => {
+    const gitignore = orchestrator.generateGitignore(mockTechs);
+    expect(gitignore).toContain("node_modules/");
+    expect(gitignore).toContain(".env");
+    expect(gitignore).toContain("*.db");
+  });
+
+  it("generates devcontainer.json", () => {
+    const devcontainer = JSON.parse(orchestrator.generateDevcontainer(mockStack, mockTechs));
+    expect(devcontainer.name).toBe("Test Stack");
+    expect(devcontainer.forwardPorts).toContain(3000);
+    expect(devcontainer.forwardPorts).toContain(5432);
+    expect(devcontainer.features).toHaveProperty("ghcr.io/devcontainers/features/node:1");
+    expect(devcontainer.features).toHaveProperty(
+      "ghcr.io/devcontainers/features/docker-in-docker:2",
+    );
+  });
+
+  it("returns null docker-compose when no docker services", () => {
+    const noDockerStack: StackDefinition = {
+      ...mockStack,
+      technologies: [{ technologyId: "nodejs", version: "22", port: 3000 }],
+    };
+    const output = orchestrator.generate(noDockerStack);
+    expect(output.dockerCompose).toBeNull();
+  });
+});

package/src/__tests__/stack-engine.test.ts

@@ -0,0 +1,328 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { closeDatabase, getDatabase } from "../db/database.js";
+import { RulesEngine } from "../engine/rules-engine.js";
+import { StackEngine } from "../engine/stack-engine.js";
+import type { Technology } from "../types/technology.js";
+
+// Minimal technology fixtures for testing
+function makeTech(overrides: Partial<Technology> & { id: string; name: string }): Technology {
+  return {
+    category: "backend",
+    description: "Test technology",
+    website: "https://example.com",
+    versions: [{ version: "1.0.0" }],
+    defaultVersion: "1.0.0",
+    requires: [],
+    incompatibleWith: [],
+    suggestedWith: [],
+    envVars: {},
+    configFiles: [],
+    lastVerified: "2026-01-01",
+    tags: [],
+    ...overrides,
+  };
+}
+
+const fakeTechs: Technology[] = [
+  makeTech({ id: "nodejs", name: "Node.js", category: "runtime" }),
+  makeTech({ id: "express", name: "Express", category: "backend", requires: ["nodejs"] }),
+  makeTech({ id: "postgresql", name: "PostgreSQL", category: "database", defaultPort: 5432 }),
+  makeTech({ id: "redis", name: "Redis", category: "service", defaultPort: 6379 }),
+];
+
+let tmpDbPath: string;
+let engine: StackEngine;
+
+beforeEach(() => {
+  // Use a temp file for the database so tests are isolated
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "stackweld-test-"));
+  tmpDbPath = path.join(tmpDir, "test.db");
+  // Initialize the database at the temp path
+  getDatabase(tmpDbPath);
+  const rules = new RulesEngine(fakeTechs);
+  engine = new StackEngine(rules);
+});
+
+afterEach(() => {
+  closeDatabase();
+  // Clean up temp file
+  if (tmpDbPath && fs.existsSync(tmpDbPath)) {
+    const dir = path.dirname(tmpDbPath);
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("StackEngine", () => {
+  describe("create()", () => {
+    it("creates a stack and persists it", () => {
+      const { stack, validation } = engine.create({
+        name: "test-stack",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      expect(validation.valid).toBe(true);
+      expect(stack.name).toBe("test-stack");
+      expect(stack.id).toBeTruthy();
+      expect(stack.version).toBe(1);
+
+      // Verify it's actually persisted
+      const retrieved = engine.get(stack.id);
+      expect(retrieved).not.toBeNull();
+      expect(retrieved?.name).toBe("test-stack");
+    });
+
+    it("auto-resolves dependencies", () => {
+      const { stack, validation } = engine.create({
+        name: "express-stack",
+        technologies: [{ technologyId: "express", version: "1.0.0" }],
+      });
+
+      expect(validation.valid).toBe(true);
+      // express requires nodejs, which should be auto-resolved
+      expect(validation.resolvedDependencies).toContain("nodejs");
+      const techIds = stack.technologies.map((t) => t.technologyId);
+      expect(techIds).toContain("express");
+      expect(techIds).toContain("nodejs");
+    });
+
+    it("assigns ports to technologies with defaultPort", () => {
+      const { stack, validation } = engine.create({
+        name: "db-stack",
+        technologies: [
+          { technologyId: "postgresql", version: "1.0.0" },
+          { technologyId: "redis", version: "1.0.0" },
+        ],
+      });
+
+      expect(validation.valid).toBe(true);
+      expect(validation.portAssignments.postgresql).toBe(5432);
+      expect(validation.portAssignments.redis).toBe(6379);
+    });
+
+    it("sets default profile to standard", () => {
+      const { stack } = engine.create({
+        name: "default-profile",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      expect(stack.profile).toBe("standard");
+    });
+
+    it("sets tags when provided", () => {
+      const { stack } = engine.create({
+        name: "tagged-stack",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+        tags: ["test", "dev"],
+      });
+
+      expect(stack.tags).toEqual(["test", "dev"]);
+    });
+  });
+
+  describe("list()", () => {
+    it("returns empty array when no stacks exist", () => {
+      const stacks = engine.list();
+      expect(stacks).toEqual([]);
+    });
+
+    it("returns saved stacks", () => {
+      engine.create({
+        name: "stack-a",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+      engine.create({
+        name: "stack-b",
+        technologies: [{ technologyId: "redis", version: "1.0.0" }],
+      });
+
+      const stacks = engine.list();
+      expect(stacks.length).toBe(2);
+      const names = stacks.map((s) => s.name);
+      expect(names).toContain("stack-a");
+      expect(names).toContain("stack-b");
+    });
+  });
+
+  describe("get()", () => {
+    it("returns correct stack by ID", () => {
+      const { stack: created } = engine.create({
+        name: "get-test",
+        description: "Testing get",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      const retrieved = engine.get(created.id);
+      expect(retrieved).not.toBeNull();
+      expect(retrieved?.id).toBe(created.id);
+      expect(retrieved?.name).toBe("get-test");
+      expect(retrieved?.description).toBe("Testing get");
+    });
+
+    it("returns null for non-existent ID", () => {
+      const result = engine.get("non-existent-uuid");
+      expect(result).toBeNull();
+    });
+
+    it("includes technologies in the returned stack", () => {
+      const { stack: created } = engine.create({
+        name: "tech-check",
+        technologies: [
+          { technologyId: "postgresql", version: "1.0.0" },
+          { technologyId: "redis", version: "1.0.0" },
+        ],
+      });
+
+      const retrieved = engine.get(created.id);
+      expect(retrieved?.technologies.length).toBe(2);
+      const ids = retrieved?.technologies.map((t) => t.technologyId);
+      expect(ids).toContain("postgresql");
+      expect(ids).toContain("redis");
+    });
+  });
+
+  describe("delete()", () => {
+    it("removes a stack", () => {
+      const { stack } = engine.create({
+        name: "to-delete",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      const deleted = engine.delete(stack.id);
+      expect(deleted).toBe(true);
+
+      const retrieved = engine.get(stack.id);
+      expect(retrieved).toBeNull();
+    });
+
+    it("returns false for non-existent stack", () => {
+      const deleted = engine.delete("non-existent-uuid");
+      expect(deleted).toBe(false);
+    });
+
+    it("does not affect other stacks", () => {
+      const { stack: a } = engine.create({
+        name: "keep-me",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+      const { stack: b } = engine.create({
+        name: "delete-me",
+        technologies: [{ technologyId: "redis", version: "1.0.0" }],
+      });
+
+      engine.delete(b.id);
+
+      expect(engine.get(a.id)).not.toBeNull();
+      expect(engine.get(b.id)).toBeNull();
+    });
+  });
+
+  describe("update()", () => {
+    it("modifies stack fields", () => {
+      const { stack } = engine.create({
+        name: "original",
+        description: "original desc",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      const result = engine.update(stack.id, {
+        name: "updated-name",
+        description: "new desc",
+      });
+
+      expect(result).not.toBeNull();
+      expect(result?.stack.name).toBe("updated-name");
+      expect(result?.stack.description).toBe("new desc");
+    });
+
+    it("increments version number on update", () => {
+      const { stack } = engine.create({
+        name: "versioned",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      expect(stack.version).toBe(1);
+
+      const result = engine.update(stack.id, { name: "versioned-v2" });
+      expect(result?.stack.version).toBe(2);
+
+      const result2 = engine.update(stack.id, { name: "versioned-v3" });
+      expect(result2?.stack.version).toBe(3);
+    });
+
+    it("returns null for non-existent stack", () => {
+      const result = engine.update("non-existent", { name: "nope" });
+      expect(result).toBeNull();
+    });
+
+    it("updates technologies", () => {
+      const { stack } = engine.create({
+        name: "tech-update",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      const result = engine.update(stack.id, {
+        technologies: [
+          { technologyId: "nodejs", version: "1.0.0" },
+          { technologyId: "redis", version: "1.0.0" },
+        ],
+      });
+
+      const techIds = result?.stack.technologies.map((t) => t.technologyId);
+      expect(techIds).toContain("nodejs");
+      expect(techIds).toContain("redis");
+    });
+  });
+
+  describe("version management", () => {
+    it("saves a version snapshot on create", () => {
+      const { stack } = engine.create({
+        name: "versioned-stack",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      const history = engine.getVersionHistory(stack.id);
+      expect(history.length).toBe(1);
+      expect(history[0].version).toBe(1);
+      expect(history[0].changelog).toBe("Initial creation");
+      expect(history[0].snapshot.name).toBe("versioned-stack");
+    });
+
+    it("saves a version snapshot on update", () => {
+      const { stack } = engine.create({
+        name: "multi-version",
+        technologies: [{ technologyId: "nodejs", version: "1.0.0" }],
+      });
+
+      engine.update(stack.id, { name: "multi-version-v2" });
+
+      const history = engine.getVersionHistory(stack.id);
+      expect(history.length).toBe(2);
+      // Ordered by version DESC
+      expect(history[0].version).toBe(2);
+      expect(history[1].version).toBe(1);
+    });
+
+    it("returns empty history for non-existent stack", () => {
+      const history = engine.getVersionHistory("non-existent");
+      expect(history).toEqual([]);
+    });
+
+    it("version snapshot contains full stack data", () => {
+      const { stack } = engine.create({
+        name: "snapshot-check",
+        description: "checking snapshots",
+        technologies: [{ technologyId: "postgresql", version: "1.0.0" }],
+        tags: ["prod"],
+      });
+
+      const history = engine.getVersionHistory(stack.id);
+      const snapshot = history[0].snapshot;
+      expect(snapshot.name).toBe("snapshot-check");
+      expect(snapshot.description).toBe("checking snapshots");
+      expect(snapshot.tags).toEqual(["prod"]);
+    });
+  });
+});