@stackweld/core 0.3.0 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # @stackweld/core
 
-[![Version](https://img.shields.io/badge/version-0.3.0-blue.svg)](https://github.com/mundowise/Stackweld/releases)
+[![Version](https://img.shields.io/badge/version-0.4.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.

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

@@ -1,35 +1,25 @@
-/**
- * Compose Generator — Pure function that generates docker-compose.yml content.
- * 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/compose-generator.js

@@ -1,17 +1,10 @@
-/**
- * Compose Generator — Pure function that generates docker-compose.yml content.
- * No disk I/O — returns structured data for preview or writing.
- */
+// No disk I/O — returns structured data, caller decides what to write.
 const DATA_MOUNTS = {
     postgresql: "/var/lib/postgresql/data",
     mysql: "/var/lib/mysql",
     mongodb: "/data/db",
     redis: "/data",
 };
-/**
- * Generate a docker-compose.yml preview from a list of technologies.
- * Only includes technologies that have a `dockerImage`.
- */
 export function generateComposePreview(technologies, projectName) {
     const services = [];
     const ports = {};
@@ -26,13 +19,11 @@ export function generateComposePreview(technologies, projectName) {
         lines.push(`  ${tech.id}:`);
         lines.push(`    image: ${tech.dockerImage}`);
         lines.push("    restart: unless-stopped");
-        // Ports
         if (port) {
             lines.push("    ports:");
             lines.push(`      - "${port}:${port}"`);
             ports[tech.id] = port;
         }
-        // Environment variables
         const envVars = tech.envVars ? Object.entries(tech.envVars) : [];
         if (envVars.length > 0) {
             lines.push("    environment:");
@@ -40,7 +31,6 @@ export function generateComposePreview(technologies, projectName) {
                 lines.push(`      ${key}: "${value}"`);
             }
         }
-        // Health check
         if (tech.healthCheck) {
             lines.push("    healthcheck:");
             if (tech.healthCheck.command) {
@@ -59,7 +49,6 @@ export function generateComposePreview(technologies, projectName) {
                 lines.push(`      retries: ${tech.healthCheck.retries}`);
             }
         }
-        // Volumes for databases
         const mountPath = DATA_MOUNTS[tech.id];
         if (mountPath && tech.category === "database") {
             const volName = `${tech.id}_data`;
@@ -67,12 +56,10 @@ export function generateComposePreview(technologies, projectName) {
             lines.push(`      - ${volName}:${mountPath}`);
             volumes.push(volName);
         }
-        // Network
         lines.push("    networks:");
         lines.push(`      - ${networkName}`);
         lines.push("");
     }
-    // Named volumes
     if (volumes.length > 0) {
         lines.push("volumes:");
         for (const vol of volumes) {
@@ -80,7 +67,6 @@ export function generateComposePreview(technologies, projectName) {
         }
         lines.push("");
     }
-    // Network
     lines.push("networks:");
     lines.push(`  ${networkName}:`);
     lines.push("    driver: bridge");

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/license-manager.d.ts

@@ -0,0 +1,29 @@
+export type LicenseTier = "community" | "pro" | "enterprise";
+export interface LicenseInfo {
+    tier: LicenseTier;
+    email: string | null;
+    validUntil: string | null;
+    active: boolean;
+}
+export interface FeatureGate {
+    feature: string;
+    requiredTier: LicenseTier;
+    description: string;
+}
+export declare function activateLicense(key: string, email: string): {
+    success: boolean;
+    message: string;
+};
+export declare function deactivateLicense(): {
+    success: boolean;
+    message: string;
+};
+export declare function getLicenseInfo(): LicenseInfo;
+export declare function checkFeatureAccess(feature: string): {
+    allowed: boolean;
+    requiredTier: LicenseTier;
+    message: string;
+};
+export declare function listFeatures(): FeatureGate[];
+export declare function getFeatureTier(feature: string): LicenseTier;
+//# sourceMappingURL=license-manager.d.ts.map

package/dist/engine/license-manager.js

@@ -0,0 +1,130 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+const PRO_FEATURES = [
+    {
+        feature: "ai",
+        requiredTier: "pro",
+        description: "AI-powered suggestions, README generation, and architecture explanations",
+    },
+    {
+        feature: "infra",
+        requiredTier: "pro",
+        description: "Infrastructure as Code generation (VPS, AWS, GCP)",
+    },
+    { feature: "cost", requiredTier: "pro", description: "Hosting cost estimation across providers" },
+    { feature: "benchmark", requiredTier: "pro", description: "Stack performance profiling" },
+    { feature: "migrate", requiredTier: "pro", description: "Technology migration planner" },
+    { feature: "deploy", requiredTier: "pro", description: "Deployment configuration generation" },
+    { feature: "plugin-install", requiredTier: "pro", description: "Install community plugins" },
+    { feature: "cloud-sync", requiredTier: "enterprise", description: "Sync stacks across machines" },
+    {
+        feature: "team-standards",
+        requiredTier: "enterprise",
+        description: "Enforce team-wide stack standards",
+    },
+    {
+        feature: "audit-log",
+        requiredTier: "enterprise",
+        description: "Detailed audit trail of all operations",
+    },
+];
+const TIER_HIERARCHY = {
+    community: 0,
+    pro: 1,
+    enterprise: 2,
+};
+function getLicensePath() {
+    const home = process.env.HOME || process.env.USERPROFILE || "~";
+    return path.join(home, ".stackweld", "license.json");
+}
+function hashKey(key) {
+    return createHash("sha256").update(key).digest("hex");
+}
+function validateKeyFormat(key) {
+    // Format: SW-PRO-XXXX-XXXX-XXXX or SW-ENT-XXXX-XXXX-XXXX
+    return /^SW-(PRO|ENT)-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/.test(key);
+}
+function tierFromKey(key) {
+    if (key.startsWith("SW-ENT-"))
+        return "enterprise";
+    if (key.startsWith("SW-PRO-"))
+        return "pro";
+    return "community";
+}
+export function activateLicense(key, email) {
+    if (!validateKeyFormat(key)) {
+        return {
+            success: false,
+            message: "Invalid license key format. Expected: SW-PRO-XXXX-XXXX-XXXX",
+        };
+    }
+    const tier = tierFromKey(key);
+    const licensePath = getLicensePath();
+    const dir = path.dirname(licensePath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const license = {
+        keyHash: hashKey(key),
+        tier,
+        email,
+        activatedAt: new Date().toISOString(),
+        validUntil: null,
+    };
+    fs.writeFileSync(licensePath, JSON.stringify(license, null, 2), "utf-8");
+    return {
+        success: true,
+        message: `${tier.charAt(0).toUpperCase() + tier.slice(1)} license activated for ${email}`,
+    };
+}
+export function deactivateLicense() {
+    const licensePath = getLicensePath();
+    if (fs.existsSync(licensePath)) {
+        fs.unlinkSync(licensePath);
+        return { success: true, message: "License deactivated. Reverted to Community tier." };
+    }
+    return { success: false, message: "No active license found." };
+}
+export function getLicenseInfo() {
+    const licensePath = getLicensePath();
+    if (!fs.existsSync(licensePath)) {
+        return { tier: "community", email: null, validUntil: null, active: false };
+    }
+    try {
+        const data = JSON.parse(fs.readFileSync(licensePath, "utf-8"));
+        const expired = data.validUntil ? new Date(data.validUntil) < new Date() : false;
+        return {
+            tier: expired ? "community" : data.tier,
+            email: data.email,
+            validUntil: data.validUntil,
+            active: !expired,
+        };
+    }
+    catch {
+        return { tier: "community", email: null, validUntil: null, active: false };
+    }
+}
+export function checkFeatureAccess(feature) {
+    const gate = PRO_FEATURES.find((f) => f.feature === feature);
+    if (!gate)
+        return { allowed: true, requiredTier: "community", message: "" };
+    const license = getLicenseInfo();
+    const userLevel = TIER_HIERARCHY[license.tier];
+    const requiredLevel = TIER_HIERARCHY[gate.requiredTier];
+    if (userLevel >= requiredLevel) {
+        return { allowed: true, requiredTier: gate.requiredTier, message: "" };
+    }
+    return {
+        allowed: false,
+        requiredTier: gate.requiredTier,
+        message: `"${gate.description}" requires a ${gate.requiredTier} license. Upgrade at https://stackweld.dev/pro`,
+    };
+}
+export function listFeatures() {
+    return PRO_FEATURES;
+}
+export function getFeatureTier(feature) {
+    const gate = PRO_FEATURES.find((f) => f.feature === feature);
+    return gate?.requiredTier ?? "community";
+}
+//# sourceMappingURL=license-manager.js.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