@stackweld/core 0.2.1 → 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Orlando Fernandez / XPlus Technologies LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# @stackweld/core
+
+[![Version](https://img.shields.io/badge/version-0.3.0-blue.svg)](https://github.com/mundowise/Stackweld/releases)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+The core engine for Stackweld. Handles stack persistence, compatibility rules, scaffolding orchestration, Docker lifecycle, and all analysis modules.
+
+This package is an internal dependency — you do not use it directly. Install `@stackweld/cli` instead.
+
+## What it contains
+
+```
+src/
+  db/          SQLite persistence layer (better-sqlite3)
+  docker/      Docker Compose generation and runtime manager
+  engine/      All analysis and intelligence modules:
+               compatibility, env-sync, detect, compose-preview,
+               health, migration, diff, share, infra, lint,
+               benchmark, cost, learn, plugin
+  scaffold/    Scaffold orchestrator + tech installer
+  types/       Shared TypeScript types
+  index.ts     Public API surface
+```
+
+### Key exports
+
+```typescript
+import {
+  StackEngine,         // Create, save, load, delete stacks (SQLite)
+  RulesEngine,         // Validate technology combinations, resolve dependencies
+  ScaffoldOrchestrator,// Run official CLI tools (create-next-app, django-admin...)
+  TechInstaller,       // Install per-technology extras (Prisma, NextAuth, Vitest...)
+  DockerManager,       // docker compose up/down/status/logs
+  scoreCompatibility,  // Score two technologies (0-100)
+  checkProjectHealth,  // Audit an existing project directory
+  planMigration,       // Step-by-step migration plan between technologies
+  estimateCost,        // Monthly hosting cost estimate across providers
+  detectStack,         // Detect stack from existing project files
+  generateInfra,       // Generate Dockerfile + nginx / CloudFormation / Terraform
+} from '@stackweld/core';
+```
+
+## Requirements
+
+- Node.js >= 22.0.0
+- Docker + Docker Compose (for runtime operations)
+
+## Repository
+
+[github.com/mundowise/Stackweld](https://github.com/mundowise/Stackweld)
+
+## License
+
+MIT

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