@stackweld/core 0.3.0 → 0.3.1

package/dist/__tests__/compatibility-scorer.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=compatibility-scorer.test.d.ts.map
+//# sourceMappingURL=compatibility-scorer.test.d.ts.map

package/dist/__tests__/rules-engine.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=rules-engine.test.d.ts.map
+//# sourceMappingURL=rules-engine.test.d.ts.map

package/dist/__tests__/scaffold-orchestrator.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=scaffold-orchestrator.test.d.ts.map
+//# sourceMappingURL=scaffold-orchestrator.test.d.ts.map

package/dist/__tests__/stack-engine.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=stack-engine.test.d.ts.map
+//# sourceMappingURL=stack-engine.test.d.ts.map

package/dist/db/database.d.ts

@@ -6,4 +6,4 @@ import Database from "better-sqlite3";
 export declare function getDatabase(dbPath?: string): Database.Database;
 export declare function closeDatabase(): void;
 export declare function getDefaultDbPath(): string;
-//# sourceMappingURL=database.d.ts.map
+//# sourceMappingURL=database.d.ts.map

package/dist/engine/compatibility-scorer.d.ts

@@ -4,34 +4,31 @@
  */
 import type { Technology } from "../types/index.js";
 export interface CompatibilityResult {
-  score: number;
-  grade: "S" | "A" | "B" | "C" | "D" | "F";
-  factors: CompatibilityFactor[];
-  recommendation: string;
+    score: number;
+    grade: "S" | "A" | "B" | "C" | "D" | "F";
+    factors: CompatibilityFactor[];
+    recommendation: string;
 }
 export interface CompatibilityFactor {
-  label: string;
-  points: number;
-  description: string;
+    label: string;
+    points: number;
+    description: string;
 }
 export interface StackScoreResult {
-  overall: number;
-  grade: string;
-  pairs: Array<{
-    a: string;
-    b: string;
-    score: number;
-  }>;
+    overall: number;
+    grade: string;
+    pairs: Array<{
+        a: string;
+        b: string;
+        score: number;
+    }>;
 }
 /**
  * Score the compatibility between two technologies (0-100).
  */
-export declare function scoreCompatibility(
-  techA: Technology,
-  techB: Technology,
-): CompatibilityResult;
+export declare function scoreCompatibility(techA: Technology, techB: Technology): CompatibilityResult;
 /**
  * Score an entire stack by evaluating all unique pairs.
  */
 export declare function scoreStack(technologies: Technology[]): StackScoreResult;
-//# sourceMappingURL=compatibility-scorer.d.ts.map
+//# sourceMappingURL=compatibility-scorer.d.ts.map

package/dist/engine/compose-generator.d.ts

@@ -3,33 +3,31 @@
  * No disk I/O — returns structured data for preview or writing.
  */
 export interface ComposePreviewResult {
-  yaml: string;
-  services: string[];
-  ports: Record<string, number>;
-  volumes: string[];
+    yaml: string;
+    services: string[];
+    ports: Record<string, number>;
+    volumes: string[];
 }
 interface ComposeTechnology {
-  id: string;
-  name: string;
-  category?: string;
-  dockerImage?: string;
-  defaultPort?: number;
-  envVars?: Record<string, string>;
-  healthCheck?: {
-    endpoint?: string;
-    command?: string;
-    interval?: string;
-    timeout?: string;
-    retries?: number;
-  };
-  port?: number;
+    id: string;
+    name: string;
+    category?: string;
+    dockerImage?: string;
+    defaultPort?: number;
+    envVars?: Record<string, string>;
+    healthCheck?: {
+        endpoint?: string;
+        command?: string;
+        interval?: string;
+        timeout?: string;
+        retries?: number;
+    };
+    port?: number;
 }
 /**
  * Generate a docker-compose.yml preview from a list of technologies.
  * Only includes technologies that have a `dockerImage`.
  */
-export declare function generateComposePreview(
-  technologies: ComposeTechnology[],
-  projectName: string,
-): ComposePreviewResult;
-//# sourceMappingURL=compose-generator.d.ts.map
+export declare function generateComposePreview(technologies: ComposeTechnology[], projectName: string): ComposePreviewResult;
+export {};
+//# sourceMappingURL=compose-generator.d.ts.map

package/dist/engine/cost-estimator.d.ts

@@ -3,20 +3,20 @@
  */
 import type { Technology } from "../types/technology.js";
 export interface CostItem {
-  service: string;
-  provider: string;
-  monthlyCost: string;
-  notes: string;
+    service: string;
+    provider: string;
+    monthlyCost: string;
+    notes: string;
 }
 export interface CostEstimate {
-  monthly: {
-    min: number;
-    max: number;
-    currency: string;
-  };
-  breakdown: CostItem[];
-  tier: "free" | "budget" | "standard" | "premium";
-  notes: string[];
+    monthly: {
+        min: number;
+        max: number;
+        currency: string;
+    };
+    breakdown: CostItem[];
+    tier: "free" | "budget" | "standard" | "premium";
+    notes: string[];
 }
 export declare function estimateCost(technologies: Technology[]): CostEstimate;
-//# sourceMappingURL=cost-estimator.d.ts.map
+//# sourceMappingURL=cost-estimator.d.ts.map

package/dist/engine/env-analyzer.d.ts

@@ -2,23 +2,23 @@
  * Environment Analyzer — Sync .env files and detect dangerous values.
  */
 export interface EnvVar {
-  key: string;
-  value: string;
-  line: number;
+    key: string;
+    value: string;
+    line: number;
 }
 export interface EnvSyncResult {
-  missing: string[];
-  extra: string[];
-  dangerous: EnvDangerousVar[];
-  total: {
-    example: number;
-    actual: number;
-  };
+    missing: string[];
+    extra: string[];
+    dangerous: EnvDangerousVar[];
+    total: {
+        example: number;
+        actual: number;
+    };
 }
 export interface EnvDangerousVar {
-  key: string;
-  value: string;
-  reason: string;
+    key: string;
+    value: string;
+    reason: string;
 }
 /**
  * Parse a .env file content into an array of key/value pairs.
@@ -33,4 +33,4 @@ export declare function syncEnv(exampleContent: string, actualContent: string):
  * Detect environment variables with insecure or placeholder values.
  */
 export declare function checkDangerous(vars: EnvVar[]): EnvDangerousVar[];
-//# sourceMappingURL=env-analyzer.d.ts.map
+//# sourceMappingURL=env-analyzer.d.ts.map

package/dist/engine/health-checker.d.ts

@@ -2,19 +2,19 @@
  * Stack Health Monitor — Checks project health across multiple dimensions.
  */
 export interface HealthReport {
-  overall: "healthy" | "warning" | "critical";
-  checks: HealthCheck[];
-  summary: {
-    passed: number;
-    warnings: number;
-    critical: number;
-  };
+    overall: "healthy" | "warning" | "critical";
+    checks: HealthCheck[];
+    summary: {
+        passed: number;
+        warnings: number;
+        critical: number;
+    };
 }
 export interface HealthCheck {
-  name: string;
-  status: "pass" | "warn" | "fail";
-  message: string;
-  suggestion?: string;
+    name: string;
+    status: "pass" | "warn" | "fail";
+    message: string;
+    suggestion?: string;
 }
 export declare function checkProjectHealth(projectPath: string): HealthReport;
-//# sourceMappingURL=health-checker.d.ts.map
+//# sourceMappingURL=health-checker.d.ts.map

package/dist/engine/health-checker.js

@@ -1,7 +1,7 @@
 /**
  * Stack Health Monitor — Checks project health across multiple dimensions.
  */
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 // ─── Helpers ──────────────────────────────────────────
@@ -18,18 +18,26 @@ function readFileContent(filePath) {
 }
 function execQuiet(command, cwd) {
     try {
-        return execSync(command, { stdio: "pipe", timeout: 10000, cwd }).toString().trim();
+        const parts = command.split(/\s+/).filter(Boolean);
+        return execFileSync(parts[0], parts.slice(1), { stdio: "pipe", timeout: 10000, cwd })
+            .toString()
+            .trim();
     }
     catch {
         return null;
     }
 }
 function getDirSizeMB(dirPath) {
-    const result = execQuiet(`du -sm "${dirPath}" 2>/dev/null`);
-    if (!result)
+    try {
+        const result = execFileSync("du", ["-sm", dirPath], { stdio: "pipe", timeout: 10000 })
+            .toString()
+            .trim();
+        const match = result.match(/^(\d+)/);
+        return match ? parseInt(match[1], 10) : null;
+    }
+    catch {
         return null;
-    const match = result.match(/^(\d+)/);
-    return match ? parseInt(match[1], 10) : null;
+    }
 }
 // ─── Individual Checks ───────────────────────────────
 function checkLockFile(projectPath) {

package/dist/engine/infra-generator.d.ts

@@ -4,23 +4,20 @@
  */
 export type DeployTarget = "vps" | "aws" | "gcp";
 export interface InfraOutput {
-  target: DeployTarget;
-  files: Array<{
-    path: string;
-    content: string;
-  }>;
-  instructions: string[];
+    target: DeployTarget;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+    instructions: string[];
 }
 interface InfraTechnology {
-  id: string;
-  name: string;
-  category: string;
-  dockerImage?: string;
-  defaultPort?: number;
+    id: string;
+    name: string;
+    category: string;
+    dockerImage?: string;
+    defaultPort?: number;
 }
-export declare function generateInfra(
-  technologies: InfraTechnology[],
-  projectName: string,
-  target: DeployTarget,
-): InfraOutput;
-//# sourceMappingURL=infra-generator.d.ts.map
+export declare function generateInfra(technologies: InfraTechnology[], projectName: string, target: DeployTarget): InfraOutput;
+export {};
+//# sourceMappingURL=infra-generator.d.ts.map

package/dist/engine/migration-planner.d.ts

@@ -3,32 +3,28 @@
  */
 import type { Technology } from "../types/technology.js";
 export interface MigrationStep {
-  order: number;
-  title: string;
-  description: string;
-  commands?: string[];
-  files?: string[];
+    order: number;
+    title: string;
+    description: string;
+    commands?: string[];
+    files?: string[];
 }
 export interface MigrationPlan {
-  from: {
-    id: string;
-    name: string;
-  };
-  to: {
-    id: string;
-    name: string;
-  };
-  steps: MigrationStep[];
-  difficulty: "easy" | "moderate" | "hard" | "expert";
-  estimatedTime: string;
+    from: {
+        id: string;
+        name: string;
+    };
+    to: {
+        id: string;
+        name: string;
+    };
+    steps: MigrationStep[];
+    difficulty: "easy" | "moderate" | "hard" | "expert";
+    estimatedTime: string;
 }
 /**
  * Generate a migration plan between two technologies.
  * Uses known migration paths when available, otherwise generates generic steps.
  */
-export declare function planMigration(
-  fromId: string,
-  toId: string,
-  techs: Technology[],
-): MigrationPlan;
-//# sourceMappingURL=migration-planner.d.ts.map
+export declare function planMigration(fromId: string, toId: string, techs: Technology[]): MigrationPlan;
+//# sourceMappingURL=migration-planner.d.ts.map

package/dist/engine/performance-profiler.d.ts

@@ -3,20 +3,20 @@
  */
 import type { Technology, TechnologyCategory } from "../types/technology.js";
 export interface TechPerformance {
-  id: string;
-  name: string;
-  category: TechnologyCategory;
-  perf: "fast" | "moderate" | "heavy";
-  note: string;
+    id: string;
+    name: string;
+    category: TechnologyCategory;
+    perf: "fast" | "moderate" | "heavy";
+    note: string;
 }
 export interface PerformanceProfile {
-  stackName: string;
-  rating: "blazing" | "fast" | "moderate" | "heavy";
-  estimatedReqPerSec: string;
-  estimatedColdStart: string;
-  estimatedMemory: string;
-  notes: string[];
-  techProfiles: TechPerformance[];
+    stackName: string;
+    rating: "blazing" | "fast" | "moderate" | "heavy";
+    estimatedReqPerSec: string;
+    estimatedColdStart: string;
+    estimatedMemory: string;
+    notes: string[];
+    techProfiles: TechPerformance[];
 }
 export declare function profilePerformance(technologies: Technology[]): PerformanceProfile;
-//# sourceMappingURL=performance-profiler.d.ts.map
+//# sourceMappingURL=performance-profiler.d.ts.map

package/dist/engine/preferences.d.ts

@@ -2,12 +2,12 @@
  * Preferences — Persistent user preferences stored in SQLite.
  */
 export interface UserPreferences {
-  editor: string;
-  packageManager: string;
-  shell: string;
-  dockerMode: string;
-  defaultProfile: string;
-  theme: string;
+    editor: string;
+    packageManager: string;
+    shell: string;
+    dockerMode: string;
+    defaultProfile: string;
+    theme: string;
 }
 /** Get all preferences, merged with defaults. */
 export declare function getPreferences(): UserPreferences;
@@ -21,4 +21,4 @@ export declare function resetPreferences(): void;
 export declare function getPreferenceKeys(): (keyof UserPreferences)[];
 /** Get default values. */
 export declare function getDefaultPreferences(): UserPreferences;
-//# sourceMappingURL=preferences.d.ts.map
+//# sourceMappingURL=preferences.d.ts.map

package/dist/engine/runtime-manager.d.ts

@@ -4,62 +4,52 @@
  */
 import type { RuntimeState, ServiceStatus, Technology } from "../types/index.js";
 export interface RuntimeOptions {
-  composePath: string;
-  projectDir: string;
+    composePath: string;
+    projectDir: string;
 }
 export declare class RuntimeManager {
-  private technologies;
-  constructor(technologies: Technology[]);
-  /**
-   * Start all services with docker compose up.
-   */
-  up(
-    opts: RuntimeOptions,
-    detach?: boolean,
-  ): {
-    success: boolean;
-    output: string;
-  };
-  /**
-   * Stop all services.
-   */
-  down(
-    opts: RuntimeOptions,
-    volumes?: boolean,
-  ): {
-    success: boolean;
-    output: string;
-  };
-  /**
-   * Get status of all services in the compose file.
-   */
-  status(opts: RuntimeOptions): ServiceStatus[];
-  /**
-   * Get logs for a specific service or all services.
-   */
-  logs(opts: RuntimeOptions, service?: string, tail?: number, follow?: boolean): string;
-  /**
-   * Wait for all services to be healthy.
-   */
-  waitForHealthy(
-    opts: RuntimeOptions,
-    timeoutMs?: number,
-    intervalMs?: number,
-  ): Promise<{
-    healthy: boolean;
-    services: ServiceStatus[];
-  }>;
-  /**
-   * Build RuntimeState from current container status.
-   */
-  getRuntimeState(projectId: string, opts: RuntimeOptions): RuntimeState;
-  /**
-   * Check if docker compose file exists at path.
-   */
-  composeExists(projectDir: string): string | null;
-  /**
-   * Check if Docker is available.
-   */
-  isDockerAvailable(): boolean;
+    private technologies;
+    constructor(technologies: Technology[]);
+    /**
+     * Start all services with docker compose up.
+     */
+    up(opts: RuntimeOptions, detach?: boolean): {
+        success: boolean;
+        output: string;
+    };
+    /**
+     * Stop all services.
+     */
+    down(opts: RuntimeOptions, volumes?: boolean): {
+        success: boolean;
+        output: string;
+    };
+    /**
+     * Get status of all services in the compose file.
+     */
+    status(opts: RuntimeOptions): ServiceStatus[];
+    /**
+     * Get logs for a specific service or all services.
+     */
+    logs(opts: RuntimeOptions, service?: string, tail?: number, follow?: boolean): string;
+    /**
+     * Wait for all services to be healthy.
+     */
+    waitForHealthy(opts: RuntimeOptions, timeoutMs?: number, intervalMs?: number): Promise<{
+        healthy: boolean;
+        services: ServiceStatus[];
+    }>;
+    /**
+     * Build RuntimeState from current container status.
+     */
+    getRuntimeState(projectId: string, opts: RuntimeOptions): RuntimeState;
+    /**
+     * Check if docker compose file exists at path.
+     */
+    composeExists(projectDir: string): string | null;
+    /**
+     * Check if Docker is available.
+     */
+    isDockerAvailable(): boolean;
 }
-//# sourceMappingURL=runtime-manager.d.ts.map
+//# sourceMappingURL=runtime-manager.d.ts.map

package/dist/engine/runtime-manager.js

@@ -2,7 +2,7 @@
  * Runtime Manager — Manages Docker Compose lifecycle for stacks.
  * Handles up, down, status, logs, and health check waiting.
  */
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 export class RuntimeManager {
@@ -14,9 +14,11 @@ export class RuntimeManager {
      * Start all services with docker compose up.
      */
     up(opts, detach = true) {
-        const flags = detach ? "-d" : "";
+        const args = ["compose", "-f", opts.composePath, "up"];
+        if (detach)
+            args.push("-d");
         try {
-            const output = execSync(`docker compose -f "${opts.composePath}" up ${flags}`, {
+            const output = execFileSync("docker", args, {
                 cwd: opts.projectDir,
                 stdio: "pipe",
                 timeout: 120_000,
@@ -32,9 +34,11 @@ export class RuntimeManager {
      * Stop all services.
      */
     down(opts, volumes = false) {
+        const args = ["compose", "-f", opts.composePath, "down"];
+        if (volumes)
+            args.push("--volumes");
         try {
-            const volumesFlag = volumes ? " --volumes" : "";
-            const output = execSync(`docker compose -f "${opts.composePath}" down${volumesFlag}`, {
+            const output = execFileSync("docker", args, {
                 cwd: opts.projectDir,
                 stdio: "pipe",
                 timeout: 60_000,
@@ -51,7 +55,7 @@ export class RuntimeManager {
      */
     status(opts) {
         try {
-            const raw = execSync(`docker compose -f "${opts.composePath}" ps --format json`, {
+            const raw = execFileSync("docker", ["compose", "-f", opts.composePath, "ps", "--format", "json"], {
                 cwd: opts.projectDir,
                 stdio: "pipe",
                 timeout: 10_000,
@@ -112,10 +116,20 @@ export class RuntimeManager {
      * Get logs for a specific service or all services.
      */
     logs(opts, service, tail = 50, follow = false) {
+        if (service && !/^[a-zA-Z0-9_-]+$/.test(service)) {
+            throw new Error(`Invalid service name: ${service}`);
+        }
+        const args = ["compose", "-f", opts.composePath, "logs", "--tail", String(tail)];
+        if (follow)
+            args.push("-f");
+        if (service)
+            args.push(service);
         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();
+            return execFileSync("docker", args, {
+                cwd: opts.projectDir,
+                stdio: follow ? "inherit" : "pipe",
+                timeout: follow ? 0 : 10_000,
+            }).toString();
         }
         catch (err) {
             return err instanceof Error ? err.message : String(err);
@@ -170,7 +184,7 @@ export class RuntimeManager {
      */
     isDockerAvailable() {
         try {
-            execSync("docker info", { stdio: "pipe", timeout: 5_000 });
+            execFileSync("docker", ["info"], { stdio: "pipe", timeout: 5_000 });
             return true;
         }
         catch {