@stackweld/core 0.2.0

package/src/engine/rules-engine.ts

@@ -0,0 +1,204 @@
+/**
+ * Rules Engine — Validates technology compatibility.
+ * Source of truth for what can coexist in a stack.
+ */
+
+import type {
+  StackTechnology,
+  Technology,
+  ValidationIssue,
+  ValidationResult,
+} from "../types/index.js";
+
+export class RulesEngine {
+  private techMap: Map<string, Technology>;
+
+  constructor(technologies: Technology[]) {
+    this.techMap = new Map(technologies.map((t) => [t.id, t]));
+  }
+
+  /**
+   * Validate a set of selected technologies.
+   * Returns issues, auto-resolved dependencies, and port assignments.
+   */
+  validate(selected: StackTechnology[]): ValidationResult {
+    const issues: ValidationIssue[] = [];
+    const resolvedDependencies: string[] = [];
+    const portAssignments: Record<string, number> = {};
+    const usedPorts = new Set<number>();
+
+    const selectedIds = new Set(selected.map((s) => s.technologyId));
+
+    // 1. Check each technology exists in the registry
+    for (const sel of selected) {
+      if (!this.techMap.has(sel.technologyId)) {
+        issues.push({
+          severity: "error",
+          code: "UNKNOWN_TECHNOLOGY",
+          message: `Technology "${sel.technologyId}" not found in the registry`,
+          technologyId: sel.technologyId,
+          autoFixable: false,
+        });
+      }
+    }
+
+    // 2. Check requires — resolve missing dependencies RECURSIVELY
+    // Use a queue to process newly resolved dependencies until no more are needed
+    const toProcess = [...selectedIds];
+    const processed = new Set<string>();
+
+    while (toProcess.length > 0) {
+      const currentId = toProcess.shift()!;
+      if (processed.has(currentId)) continue;
+      processed.add(currentId);
+
+      const tech = this.techMap.get(currentId);
+      if (!tech) continue;
+
+      for (const reqId of tech.requires) {
+        if (!selectedIds.has(reqId)) {
+          const reqTech = this.techMap.get(reqId);
+          if (reqTech) {
+            resolvedDependencies.push(reqId);
+            selectedIds.add(reqId);
+            // Queue the newly added dependency so its own requires are checked
+            toProcess.push(reqId);
+            issues.push({
+              severity: "info",
+              code: "AUTO_DEPENDENCY",
+              message: `"${tech.name}" requires "${reqTech.name}" — added automatically`,
+              technologyId: currentId,
+              relatedTechnologyId: reqId,
+              autoFixable: true,
+              suggestedFix: `Add ${reqTech.name} to the stack`,
+            });
+          } else {
+            issues.push({
+              severity: "error",
+              code: "MISSING_DEPENDENCY",
+              message: `"${tech.name}" requires "${reqId}" which is not in the registry`,
+              technologyId: currentId,
+              relatedTechnologyId: reqId,
+              autoFixable: false,
+            });
+          }
+        }
+      }
+    }
+
+    // 3. Check incompatibleWith BIDIRECTIONALLY
+    // Track reported pairs to avoid duplicate issues (A-B and B-A)
+    const reportedPairs = new Set<string>();
+    const allIds = [...selectedIds];
+
+    for (const techId of allIds) {
+      const tech = this.techMap.get(techId);
+      if (!tech) continue;
+
+      for (const otherId of allIds) {
+        if (techId === otherId) continue;
+
+        const pairKey = [techId, otherId].sort().join(":");
+        if (reportedPairs.has(pairKey)) continue;
+
+        const otherTech = this.techMap.get(otherId);
+        if (!otherTech) continue;
+
+        // Bidirectional: incompatible if EITHER side lists the other
+        const aListsB = tech.incompatibleWith.includes(otherId);
+        const bListsA = otherTech.incompatibleWith.includes(techId);
+
+        if (aListsB || bListsA) {
+          reportedPairs.add(pairKey);
+          issues.push({
+            severity: "error",
+            code: "INCOMPATIBLE",
+            message: `"${tech.name}" is incompatible with "${otherTech.name}"`,
+            technologyId: techId,
+            relatedTechnologyId: otherId,
+            autoFixable: false,
+            suggestedFix: `Remove either "${tech.name}" or "${otherTech.name}" from the stack`,
+          });
+        }
+      }
+    }
+
+    // 4. Assign ports deterministically — sort by ID for stable ordering
+    const sortedTechIds = [...selectedIds].sort();
+    for (const techId of sortedTechIds) {
+      const tech = this.techMap.get(techId);
+      if (!tech?.defaultPort) continue;
+
+      let port = tech.defaultPort;
+
+      // Find a free port if default is taken
+      if (usedPorts.has(port)) {
+        const originalPort = port;
+        while (usedPorts.has(port)) {
+          port++;
+        }
+        issues.push({
+          severity: "warning",
+          code: "PORT_CONFLICT",
+          message: `Port ${originalPort} for "${tech.name}" conflicts — reassigned to ${port}`,
+          technologyId: techId,
+          autoFixable: true,
+          suggestedFix: `Using port ${port} instead of ${originalPort}`,
+        });
+      }
+
+      usedPorts.add(port);
+      portAssignments[techId] = port;
+    }
+
+    const hasErrors = issues.some((i) => i.severity === "error");
+
+    return {
+      valid: !hasErrors,
+      issues,
+      resolvedDependencies,
+      portAssignments,
+    };
+  }
+
+  /**
+   * Get suggested technologies for a given set.
+   */
+  getSuggestions(selectedIds: string[]): Technology[] {
+    const selected = new Set(selectedIds);
+    const suggestions = new Set<string>();
+
+    for (const id of selectedIds) {
+      const tech = this.techMap.get(id);
+      if (!tech) continue;
+      for (const sugId of tech.suggestedWith) {
+        if (!selected.has(sugId) && this.techMap.has(sugId)) {
+          suggestions.add(sugId);
+        }
+      }
+    }
+
+    return [...suggestions].map((id) => this.techMap.get(id)!);
+  }
+
+  /**
+   * Get a technology by ID.
+   */
+  getTechnology(id: string): Technology | undefined {
+    return this.techMap.get(id);
+  }
+
+  /**
+   * Get all technologies.
+   */
+  getAllTechnologies(): Technology[] {
+    return [...this.techMap.values()];
+  }
+
+  /**
+   * Get technologies by category.
+   */
+  getByCategory(category: string): Technology[] {
+    return [...this.techMap.values()].filter((t) => t.category === category);
+  }
+}

package/src/engine/runtime-manager.ts

@@ -0,0 +1,207 @@
+/**
+ * Runtime Manager — Manages Docker Compose lifecycle for stacks.
+ * Handles up, down, status, logs, and health check waiting.
+ */
+
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { RuntimeState, ServiceStatus, Technology } from "../types/index.js";
+
+export interface RuntimeOptions {
+  composePath: string;
+  projectDir: string;
+}
+
+export class RuntimeManager {
+  private technologies: Map<string, Technology>;
+
+  constructor(technologies: Technology[]) {
+    this.technologies = new Map(technologies.map((t) => [t.id, t]));
+  }
+
+  /**
+   * Start all services with docker compose up.
+   */
+  up(opts: RuntimeOptions, detach = true): { success: boolean; output: string } {
+    const flags = detach ? "-d" : "";
+    try {
+      const output = execSync(`docker compose -f "${opts.composePath}" up ${flags}`, {
+        cwd: opts.projectDir,
+        stdio: "pipe",
+        timeout: 120_000,
+      }).toString();
+      return { success: true, output };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, output: message };
+    }
+  }
+
+  /**
+   * Stop all services.
+   */
+  down(opts: RuntimeOptions, volumes = false): { success: boolean; output: string } {
+    try {
+      const volumesFlag = volumes ? " --volumes" : "";
+      const output = execSync(`docker compose -f "${opts.composePath}" down${volumesFlag}`, {
+        cwd: opts.projectDir,
+        stdio: "pipe",
+        timeout: 60_000,
+      }).toString();
+      return { success: true, output };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, output: message };
+    }
+  }
+
+  /**
+   * Get status of all services in the compose file.
+   */
+  status(opts: RuntimeOptions): ServiceStatus[] {
+    try {
+      const raw = execSync(`docker compose -f "${opts.composePath}" ps --format json`, {
+        cwd: opts.projectDir,
+        stdio: "pipe",
+        timeout: 10_000,
+      }).toString();
+
+      const services: ServiceStatus[] = [];
+      const lines = raw.trim().split("\n").filter(Boolean);
+
+      for (const line of lines) {
+        try {
+          const container = JSON.parse(line);
+          const serviceName = container.Service || container.Name || "unknown";
+          const state = container.State || "unknown";
+          const health = container.Health || "";
+
+          // Try to find matching technology
+          const tech = this.technologies.get(serviceName);
+
+          let statusValue: ServiceStatus["status"];
+          if (state === "running" && health === "healthy") {
+            statusValue = "healthy";
+          } else if (state === "running" && health === "unhealthy") {
+            statusValue = "unhealthy";
+          } else if (state === "running") {
+            statusValue = "running";
+          } else if (state === "exited") {
+            statusValue = "exited";
+          } else {
+            statusValue = "stopped";
+          }
+
+          // Extract port from Publishers
+          let port: number | undefined;
+          if (container.Publishers && Array.isArray(container.Publishers)) {
+            const pub = container.Publishers.find((p: Record<string, unknown>) => p.PublishedPort);
+            if (pub) port = pub.PublishedPort as number;
+          }
+
+          services.push({
+            name: serviceName,
+            technologyId: tech?.id || serviceName,
+            containerId: container.ID,
+            status: statusValue,
+            port,
+            healthCheck:
+              health === "healthy" ? "passing" : health === "unhealthy" ? "failing" : "none",
+          });
+        } catch {
+          // Skip malformed JSON lines
+        }
+      }
+
+      return services;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get logs for a specific service or all services.
+   */
+  logs(opts: RuntimeOptions, service?: string, tail = 50, follow = false): string {
+    try {
+      const serviceArg = service || "";
+      const followFlag = follow ? " -f" : "";
+      return execSync(
+        `docker compose -f "${opts.composePath}" logs --tail ${tail}${followFlag} ${serviceArg}`,
+        { cwd: opts.projectDir, stdio: follow ? "inherit" : "pipe", timeout: follow ? 0 : 10_000 },
+      ).toString();
+    } catch (err) {
+      return err instanceof Error ? err.message : String(err);
+    }
+  }
+
+  /**
+   * Wait for all services to be healthy.
+   */
+  async waitForHealthy(
+    opts: RuntimeOptions,
+    timeoutMs = 60_000,
+    intervalMs = 2_000,
+  ): Promise<{ healthy: boolean; services: ServiceStatus[] }> {
+    const start = Date.now();
+
+    while (Date.now() - start < timeoutMs) {
+      const services = this.status(opts);
+      const hasServices = services.length > 0;
+      const allHealthy = services.every(
+        (s) => s.status === "healthy" || s.status === "running" || s.healthCheck === "none",
+      );
+
+      if (hasServices && allHealthy) {
+        return { healthy: true, services };
+      }
+
+      // Check for exited containers (failed)
+      const failed = services.filter((s) => s.status === "exited");
+      if (failed.length > 0) {
+        return { healthy: false, services };
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+
+    return { healthy: false, services: this.status(opts) };
+  }
+
+  /**
+   * Build RuntimeState from current container status.
+   */
+  getRuntimeState(projectId: string, opts: RuntimeOptions): RuntimeState {
+    return {
+      projectId,
+      services: this.status(opts),
+      composePath: opts.composePath,
+      lastChecked: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Check if docker compose file exists at path.
+   */
+  composeExists(projectDir: string): string | null {
+    const candidates = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
+    for (const name of candidates) {
+      const p = path.join(projectDir, name);
+      if (fs.existsSync(p)) return p;
+    }
+    return null;
+  }
+
+  /**
+   * Check if Docker is available.
+   */
+  isDockerAvailable(): boolean {
+    try {
+      execSync("docker info", { stdio: "pipe", timeout: 5_000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}