@stackweld/core 0.2.1 → 0.3.0

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

@@ -1,161 +0,0 @@
-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

@@ -1,328 +0,0 @@
-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"]);
-    });
-  });
-});

package/src/db/database.ts

@@ -1,112 +0,0 @@
-/**
- * Database — SQLite persistence layer for stacks, projects, and versions.
- * Uses better-sqlite3 for synchronous, reliable access.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import Database from "better-sqlite3";
-
-const SCHEMA = `
-CREATE TABLE IF NOT EXISTS stacks (
-  id TEXT PRIMARY KEY,
-  name TEXT NOT NULL UNIQUE,
-  description TEXT NOT NULL DEFAULT '',
-  profile TEXT NOT NULL DEFAULT 'standard',
-  version INTEGER NOT NULL DEFAULT 1,
-  created_at TEXT NOT NULL DEFAULT (datetime('now')),
-  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-  tags TEXT NOT NULL DEFAULT '[]'
-);
-
-CREATE TABLE IF NOT EXISTS stack_technologies (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  stack_id TEXT NOT NULL REFERENCES stacks(id) ON DELETE CASCADE,
-  technology_id TEXT NOT NULL,
-  version TEXT NOT NULL,
-  port INTEGER,
-  config TEXT DEFAULT '{}',
-  UNIQUE(stack_id, technology_id)
-);
-
-CREATE TABLE IF NOT EXISTS stack_versions (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  stack_id TEXT NOT NULL REFERENCES stacks(id) ON DELETE CASCADE,
-  version INTEGER NOT NULL,
-  changelog TEXT NOT NULL DEFAULT '',
-  snapshot TEXT NOT NULL,
-  created_at TEXT NOT NULL DEFAULT (datetime('now')),
-  UNIQUE(stack_id, version)
-);
-
-CREATE TABLE IF NOT EXISTS project_instances (
-  id TEXT PRIMARY KEY,
-  stack_id TEXT NOT NULL REFERENCES stacks(id),
-  name TEXT NOT NULL,
-  path TEXT NOT NULL,
-  template_id TEXT,
-  created_at TEXT NOT NULL DEFAULT (datetime('now')),
-  last_opened_at TEXT
-);
-
-CREATE TABLE IF NOT EXISTS project_services (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  project_id TEXT NOT NULL REFERENCES project_instances(id) ON DELETE CASCADE,
-  service_name TEXT NOT NULL,
-  technology_id TEXT,
-  port INTEGER,
-  docker_container_id TEXT,
-  status TEXT DEFAULT 'not_started',
-  UNIQUE(project_id, service_name)
-);
-
-CREATE TABLE IF NOT EXISTS user_tech_notes (
-  tech_id TEXT PRIMARY KEY,
-  rating INTEGER CHECK(rating >= 1 AND rating <= 5),
-  notes TEXT DEFAULT '',
-  last_used_at TEXT
-);
-
-CREATE INDEX IF NOT EXISTS idx_stack_tech_stack ON stack_technologies(stack_id);
-CREATE INDEX IF NOT EXISTS idx_stack_versions_stack ON stack_versions(stack_id);
-CREATE INDEX IF NOT EXISTS idx_projects_stack ON project_instances(stack_id);
-CREATE INDEX IF NOT EXISTS idx_project_services_project ON project_services(project_id);
-
-CREATE TABLE IF NOT EXISTS custom_templates (
-  id TEXT PRIMARY KEY,
-  name TEXT NOT NULL UNIQUE,
-  description TEXT NOT NULL DEFAULT '',
-  profile TEXT NOT NULL DEFAULT 'standard',
-  technology_ids TEXT NOT NULL DEFAULT '[]',
-  created_at TEXT NOT NULL DEFAULT (datetime('now'))
-);
-`;
-
-let db: Database.Database | null = null;
-
-export function getDatabase(dbPath?: string): Database.Database {
-  if (db) return db;
-
-  const resolvedPath = dbPath || getDefaultDbPath();
-  const dir = path.dirname(resolvedPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-
-  db = new Database(resolvedPath);
-  db.pragma("journal_mode = WAL");
-  db.pragma("foreign_keys = ON");
-  db.exec(SCHEMA);
-
-  return db;
-}
-
-export function closeDatabase(): void {
-  if (db) {
-    db.close();
-    db = null;
-  }
-}
-
-export function getDefaultDbPath(): string {
-  const home = process.env.HOME || process.env.USERPROFILE || ".";
-  return path.join(home, ".stackweld", "stackweld.db");
-}

package/src/db/index.ts

@@ -1 +0,0 @@
-export { closeDatabase, getDatabase, getDefaultDbPath } from "./database.js";