@prajwolkc/stk 0.5.0 → 0.5.1

package/dist/commands/init.js

@@ -1,15 +1,165 @@
 import { Command } from "commander";
 import chalk from "chalk";
-import { writeFileSync, existsSync } from "fs";
+import ora from "ora";
+import { writeFileSync, readFileSync, existsSync } from "fs";
 import { basename } from "path";
 import { CONFIG_FILE, KNOWN_SERVICES } from "../lib/config.js";
 import { templates, listTemplates } from "../templates/index.js";
+import { ingestProject, loadBrainStore, saveBrainStore, pullFromCloud, pushToCloud } from "../services/brain.js";
 const DEPLOY_PROVIDERS = ["railway", "vercel", "fly", "render", "aws"];
+/** Scan project files to detect what stack is being used */
+function detectStackFromFiles() {
+    const detected = {};
+    const stack = [];
+    let projectType = "unknown";
+    // 1. Check env vars (existing behavior)
+    const envChecks = {
+        railway: ["RAILWAY_API_TOKEN"],
+        vercel: ["VERCEL_TOKEN"],
+        fly: ["FLY_API_TOKEN"],
+        render: ["RENDER_API_KEY"],
+        aws: ["AWS_ACCESS_KEY_ID"],
+        database: ["DATABASE_URL"],
+        mongodb: ["MONGODB_URL", "MONGO_URL"],
+        redis: ["REDIS_URL"],
+        supabase: ["SUPABASE_URL"],
+        r2: ["CLOUDFLARE_ACCOUNT_ID"],
+        stripe: ["STRIPE_SECRET_KEY"],
+    };
+    for (const [service, vars] of Object.entries(envChecks)) {
+        if (vars.some((v) => process.env[v])) {
+            detected[service] = true;
+        }
+    }
+    // 2. Scan package.json files for dependencies
+    const pkgPaths = [
+        "package.json",
+        "node-backend/package.json",
+        "backend/package.json",
+        "server/package.json",
+        "api/package.json",
+        "frontend/package.json",
+        "web/package.json",
+        "client/package.json",
+    ];
+    const allDeps = {};
+    for (const p of pkgPaths) {
+        if (existsSync(p)) {
+            try {
+                const pkg = JSON.parse(readFileSync(p, "utf-8"));
+                Object.assign(allDeps, pkg.dependencies ?? {}, pkg.devDependencies ?? {});
+            }
+            catch { /* skip */ }
+        }
+    }
+    // Detect framework
+    if (allDeps["next"]) {
+        stack.push("Next.js");
+        projectType = "fullstack";
+    }
+    else if (allDeps["react"]) {
+        stack.push("React");
+    }
+    if (allDeps["vue"]) {
+        stack.push("Vue");
+    }
+    if (allDeps["angular"] || allDeps["@angular/core"]) {
+        stack.push("Angular");
+    }
+    if (allDeps["express"]) {
+        stack.push("Express");
+        projectType = projectType === "unknown" ? "api" : projectType;
+    }
+    if (allDeps["fastify"]) {
+        stack.push("Fastify");
+        projectType = projectType === "unknown" ? "api" : projectType;
+    }
+    if (allDeps["hono"]) {
+        stack.push("Hono");
+    }
+    // Detect ORM/DB
+    if (allDeps["prisma"] || allDeps["@prisma/client"]) {
+        stack.push("Prisma");
+        detected.database = true;
+    }
+    if (allDeps["mongoose"]) {
+        stack.push("Mongoose");
+        detected.mongodb = true;
+    }
+    if (allDeps["typeorm"]) {
+        stack.push("TypeORM");
+        detected.database = true;
+    }
+    if (allDeps["drizzle-orm"]) {
+        stack.push("Drizzle");
+        detected.database = true;
+    }
+    if (allDeps["@supabase/supabase-js"]) {
+        stack.push("Supabase SDK");
+        detected.supabase = true;
+    }
+    // Detect billing/payments
+    if (allDeps["stripe"] || allDeps["@stripe/stripe-js"]) {
+        stack.push("Stripe");
+        detected.stripe = true;
+    }
+    // Detect queue/cache
+    if (allDeps["bullmq"] || allDeps["bull"] || allDeps["ioredis"]) {
+        stack.push("Redis/BullMQ");
+        detected.redis = true;
+    }
+    // Detect auth
+    if (allDeps["jsonwebtoken"])
+        stack.push("JWT Auth");
+    if (allDeps["passport"])
+        stack.push("Passport.js");
+    if (allDeps["next-auth"] || allDeps["@auth/core"])
+        stack.push("Auth.js");
+    // 3. Scan for config files that indicate deploy providers
+    if (existsSync("railway.json") || existsSync("railway.toml"))
+        detected.railway = true;
+    if (existsSync("vercel.json") || existsSync(".vercel"))
+        detected.vercel = true;
+    if (existsSync("fly.toml"))
+        detected.fly = true;
+    if (existsSync("render.yaml"))
+        detected.render = true;
+    if (existsSync("Dockerfile"))
+        stack.push("Docker");
+    // 4. Scan for Prisma schema
+    const prismaPaths = [
+        "prisma/schema.prisma",
+        "node-backend/prisma/schema.prisma",
+        "backend/prisma/schema.prisma",
+        "src/prisma/schema.prisma",
+    ];
+    for (const p of prismaPaths) {
+        if (existsSync(p)) {
+            detected.database = true;
+            if (!stack.includes("Prisma"))
+                stack.push("Prisma");
+            break;
+        }
+    }
+    // 5. Detect monorepo vs single
+    const hasMultiplePkgs = pkgPaths.filter(p => existsSync(p)).length > 1;
+    if (hasMultiplePkgs)
+        projectType = "fullstack";
+    // 6. Detect if frontend-only (static)
+    if (stack.length > 0 && !allDeps["express"] && !allDeps["fastify"] && !allDeps["hono"] && !allDeps["next"]) {
+        if (allDeps["react"] || allDeps["vue"] || allDeps["angular"]) {
+            if (projectType === "unknown")
+                projectType = "static";
+        }
+    }
+    return { detected, stack, projectType };
+}
 export const initCommand = new Command("init")
-    .description("Initialize stk config for the current project")
+    .description("Initialize stk config — auto-detects stack, ingests knowledge, syncs brain")
     .option("--force", "overwrite existing config")
     .option("-t, --template <name>", `use a starter template (${listTemplates().join(", ")})`)
     .option("--list-templates", "show available templates")
+    .option("--skip-brain", "skip brain ingest and sync")
     .action(async (opts) => {
     // List templates
     if (opts.listTemplates) {
@@ -52,31 +202,24 @@ export const initCommand = new Command("init")
             console.log(`  ${icon}  ${enabled ? chalk.white(name) : chalk.dim(name)}`);
         }
         console.log();
-        console.log(chalk.dim(`  Deploy branch: ${config.deploy?.branch ?? "main"}`));
-        console.log(chalk.dim(`  Deploy providers: ${config.deploy?.providers?.join(", ") || "none"}`));
-        console.log();
-        console.log(chalk.dim(`  Set your env vars, then run ${chalk.white("stk health")} to verify.`));
-        console.log();
+        // Run brain steps even for template init
+        if (!opts.skipBrain) {
+            await runBrainSteps(projectName);
+        }
         return;
     }
-    // Auto-detect init
-    const detected = {};
-    const envChecks = {
-        railway: ["RAILWAY_API_TOKEN"],
-        vercel: ["VERCEL_TOKEN"],
-        fly: ["FLY_API_TOKEN"],
-        render: ["RENDER_API_KEY"],
-        aws: ["AWS_ACCESS_KEY_ID"],
-        database: ["DATABASE_URL"],
-        mongodb: ["MONGODB_URL", "MONGO_URL"],
-        redis: ["REDIS_URL"],
-        supabase: ["SUPABASE_URL"],
-        r2: ["CLOUDFLARE_ACCOUNT_ID"],
-        stripe: ["STRIPE_SECRET_KEY"],
-    };
-    for (const [service, vars] of Object.entries(envChecks)) {
-        if (vars.some((v) => process.env[v])) {
-            detected[service] = true;
+    // ─── Smart Auto-detect Init ───
+    console.log();
+    const detectSpinner = ora("  Scanning project...").start();
+    const { detected, stack, projectType } = detectStackFromFiles();
+    detectSpinner.succeed("  Project scanned");
+    // Show detected stack
+    if (stack.length > 0) {
+        console.log();
+        console.log(chalk.bold("  Detected stack:"));
+        console.log(`  ${chalk.cyan(stack.join(" + "))}`);
+        if (projectType !== "unknown") {
+            console.log(`  ${chalk.dim(`Project type: ${projectType}`)}`);
         }
     }
     const config = {
@@ -94,18 +237,91 @@ export const initCommand = new Command("init")
     console.log();
     console.log(`  ${chalk.green("✓")} Created ${chalk.bold(CONFIG_FILE)}`);
     console.log();
-    console.log(chalk.bold("  Detected services:"));
+    console.log(chalk.bold("  Services:"));
     const serviceNames = Object.entries(config.services);
     for (const [name, enabled] of serviceNames) {
         const icon = enabled ? chalk.green("✓") : chalk.dim("○");
         const label = enabled
             ? chalk.white(name)
-            : chalk.dim(`${name} (not detected — enable in config)`);
+            : chalk.dim(name);
         console.log(`  ${icon}  ${label}`);
     }
+    // ─── Brain Steps ───
+    if (!opts.skipBrain) {
+        await runBrainSteps(projectName);
+    }
     console.log();
-    console.log(chalk.dim(`  Edit ${CONFIG_FILE} to enable/disable services or add config.`));
-    console.log(chalk.dim(`  Or try: ${chalk.white("stk init --template saas")} for a pre-configured stack.`));
-    console.log(chalk.dim(`  Then run ${chalk.white("stk health")} to verify.`));
+    console.log(chalk.dim(`  Run ${chalk.white("stk health")} to verify services.`));
     console.log();
 });
+/** Ingest project, pull cloud knowledge, push new knowledge */
+async function runBrainSteps(projectName) {
+    console.log();
+    console.log(chalk.bold("  Brain setup:"));
+    // Step 1: Ingest project
+    const ingestSpinner = ora("  Scanning project architecture...").start();
+    try {
+        const { entries, filesScanned } = ingestProject(process.cwd());
+        if (entries.length > 0) {
+            const store = loadBrainStore();
+            store.projects[projectName] = {
+                ingestedAt: new Date().toISOString(),
+                projectPath: process.cwd(),
+                entries,
+            };
+            saveBrainStore(store);
+            ingestSpinner.succeed(`  Ingested ${chalk.white(entries.length)} knowledge entries from ${filesScanned.length} files`);
+        }
+        else {
+            ingestSpinner.warn("  No project files found to ingest");
+        }
+    }
+    catch {
+        ingestSpinner.warn("  Ingest skipped (no recognizable files)");
+    }
+    // Step 2: Pull cloud brain (learn from other projects)
+    const pullSpinner = ora("  Pulling knowledge from cloud brain...").start();
+    try {
+        const pullResult = await pullFromCloud();
+        if (pullResult.errors.length > 0) {
+            pullSpinner.warn("  Cloud brain not available (set SUPABASE_URL + SUPABASE_SERVICE_KEY to enable)");
+        }
+        else if (pullResult.pulled > 0) {
+            pullSpinner.succeed(`  Pulled ${chalk.white(pullResult.pulled)} entries from cloud (learned from other projects)`);
+        }
+        else {
+            pullSpinner.succeed("  Cloud brain in sync");
+        }
+    }
+    catch {
+        pullSpinner.warn("  Cloud sync skipped (no connection)");
+    }
+    // Step 3: Push new knowledge to cloud
+    const pushSpinner = ora("  Sharing knowledge to cloud brain...").start();
+    try {
+        const pushResult = await pushToCloud();
+        if (pushResult.errors.length > 0) {
+            pushSpinner.warn("  Push skipped");
+        }
+        else if (pushResult.pushed > 0) {
+            pushSpinner.succeed(`  Pushed ${chalk.white(pushResult.pushed)} entries to cloud`);
+        }
+        else {
+            pushSpinner.succeed("  All knowledge already shared");
+        }
+    }
+    catch {
+        pushSpinner.warn("  Push skipped (no connection)");
+    }
+    // Show what we know from other projects
+    const store = loadBrainStore();
+    const otherProjects = Object.keys(store.projects).filter(p => p !== projectName);
+    if (otherProjects.length > 0) {
+        console.log();
+        console.log(chalk.bold("  Knowledge available from other projects:"));
+        for (const proj of otherProjects) {
+            const p = store.projects[proj];
+            console.log(`  ${chalk.green("●")} ${chalk.white(proj)} — ${p.entries.length} entries`);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prajwolkc/stk",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "One CLI to deploy, monitor, debug, and learn about your entire stack. Infrastructure monitoring, knowledge base brain, deploy watching, and GitHub issues — all from one command.",
   "type": "module",
   "license": "MIT",