chainlesschain 0.47.8 → 0.49.0

package/src/commands/stress.js

@@ -0,0 +1,252 @@
+/**
+ * Stress commands
+ * chainlesschain stress run|list|show|analyze|plan|stop|levels
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureStressTables,
+  startStressTest,
+  stopStressTest,
+  getTestResults,
+  listTestHistory,
+  analyzeBottlenecks,
+  generateCapacityPlan,
+  listLoadLevels,
+} from "../lib/stress-tester.js";
+
+function _dbFromCtx(ctx) {
+  if (!ctx.db) {
+    logger.error("Database not available");
+    process.exit(1);
+  }
+  const db = ctx.db.getDatabase();
+  ensureStressTables(db);
+  return db;
+}
+
+export function registerStressCommand(program) {
+  const stress = program
+    .command("stress")
+    .description(
+      "Federation stress testing — load simulation, bottleneck & capacity planning",
+    );
+
+  stress
+    .command("run")
+    .description("Run a stress test at a given load level")
+    .option(
+      "-l, --level <level>",
+      "Load level (light|medium|heavy|extreme)",
+      "medium",
+    )
+    .option("-c, --concurrency <n>", "Override concurrency", parseInt)
+    .option("-r, --rps <n>", "Override requests per second", parseInt)
+    .option("-d, --duration <ms>", "Override duration in ms", parseInt)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const run = startStressTest(db, {
+          level: options.level,
+          concurrency: options.concurrency,
+          requestsPerSecond: options.rps,
+          duration: options.duration,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(run, null, 2));
+        } else {
+          logger.success(`Stress test ${run.status}`);
+          logger.log(
+            `  ${chalk.bold("ID:")}          ${chalk.cyan(run.testId)}`,
+          );
+          logger.log(`  ${chalk.bold("Level:")}       ${run.loadLevel}`);
+          logger.log(
+            `  ${chalk.bold("Load:")}        ${run.concurrency} concurrent, ${run.requestsPerSecond} rps, ${run.duration}ms`,
+          );
+          const m = run.result;
+          logger.log(`  ${chalk.bold("TPS:")}         ${m.tps}`);
+          logger.log(
+            `  ${chalk.bold("Latency:")}     p50=${m.p50ResponseTime}ms p95=${m.p95ResponseTime}ms p99=${m.p99ResponseTime}ms`,
+          );
+          logger.log(
+            `  ${chalk.bold("Error rate:")}  ${(m.errorRate * 100).toFixed(2)}%`,
+          );
+          if (m.bottlenecks.length) {
+            logger.log(chalk.yellow(`  Bottlenecks:`));
+            for (const b of m.bottlenecks) {
+              logger.log(
+                `    ${chalk.yellow("•")} ${b.kind} (${b.severity}): ${b.detail}`,
+              );
+            }
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("list")
+    .description("List stress test history")
+    .option("-l, --level <level>", "Filter by load level")
+    .option(
+      "-s, --status <status>",
+      "Filter by status (running|complete|stopped)",
+    )
+    .option("--limit <n>", "Maximum entries", parseInt, 10)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = listTestHistory({
+          level: options.level,
+          status: options.status,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No stress tests recorded.");
+        } else {
+          for (const r of rows) {
+            logger.log(
+              `  ${chalk.cyan(r.testId.slice(0, 8))} ${r.loadLevel.padEnd(8)} [${r.status}] c=${r.concurrency} rps=${r.requestsPerSecond}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("show <test-id>")
+    .description("Show full results for a stress test")
+    .option("--json", "Output as JSON")
+    .action(async (testId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const r = getTestResults(testId);
+        if (options.json) {
+          console.log(JSON.stringify(r, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("ID:")}          ${chalk.cyan(r.testId)}`);
+          logger.log(`  ${chalk.bold("Level:")}       ${r.loadLevel}`);
+          logger.log(`  ${chalk.bold("Status:")}      ${r.status}`);
+          if (r.result) {
+            const m = r.result;
+            logger.log(`  ${chalk.bold("TPS:")}         ${m.tps}`);
+            logger.log(
+              `  ${chalk.bold("Latency:")}     p50=${m.p50ResponseTime}ms p95=${m.p95ResponseTime}ms p99=${m.p99ResponseTime}ms`,
+            );
+            logger.log(
+              `  ${chalk.bold("Error rate:")}  ${(m.errorRate * 100).toFixed(2)}%`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("analyze <test-id>")
+    .description("Analyze bottlenecks for a stress test")
+    .option("--json", "Output as JSON")
+    .action(async (testId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const r = analyzeBottlenecks(testId);
+        if (options.json) {
+          console.log(JSON.stringify(r, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Summary:")} ${r.summary}`);
+          for (const b of r.bottlenecks) {
+            logger.log(
+              `    ${chalk.yellow(b.kind)} (${b.severity}): ${b.detail}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("plan <test-id>")
+    .description("Generate capacity plan recommendations")
+    .option("--json", "Output as JSON")
+    .action(async (testId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const plan = generateCapacityPlan(testId);
+        if (options.json) {
+          console.log(JSON.stringify(plan, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Level:")}     ${plan.loadLevel}`);
+          logger.log(
+            `  ${chalk.bold("Target/Got:")} ${plan.targetRps} rps → ${plan.realizedTps} rps`,
+          );
+          logger.log(
+            `  ${chalk.bold("Scale:")}     ${plan.scale}× (${plan.headroom})`,
+          );
+          for (const rec of plan.recommendations) {
+            logger.log(`    ${chalk.green("→")} ${rec}`);
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("stop <test-id>")
+    .description("Mark a running stress test as stopped")
+    .action(async (testId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const r = stopStressTest(testId);
+        logger.success(`Test ${r.testId.slice(0, 8)} → ${r.status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("levels")
+    .description("List built-in load levels")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const levels = listLoadLevels();
+      if (options.json) {
+        console.log(JSON.stringify(levels, null, 2));
+      } else {
+        for (const l of levels) {
+          logger.log(
+            `  ${chalk.cyan(l.name.padEnd(8))} concurrency=${l.concurrency} rps=${l.requestsPerSecond} duration=${l.duration}ms`,
+          );
+        }
+      }
+    });
+}

package/src/commands/tech.js

@@ -0,0 +1,268 @@
+/**
+ * Tech Learning Engine commands (Phase 62)
+ * chainlesschain tech analyze|profile|detect|practice|practices|recommend|types
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureTechLearningTables,
+  analyzeTechStack,
+  getProfile,
+  detectAntiPatterns,
+  recordPractice,
+  listPractices,
+  getRecommendations,
+  TECH_TYPES,
+  PRACTICE_LEVELS,
+  ANTI_PATTERNS,
+} from "../lib/tech-learning-engine.js";
+
+function _dbFromCtx(ctx) {
+  if (!ctx.db) {
+    logger.error("Database not available");
+    process.exit(1);
+  }
+  const db = ctx.db.getDatabase();
+  ensureTechLearningTables(db);
+  return db;
+}
+
+export function registerTechCommand(program) {
+  const tech = program
+    .command("tech")
+    .description(
+      "Tech Learning Engine — stack analysis, anti-pattern detection, practice store",
+    );
+
+  tech
+    .command("types")
+    .description("List known tech types, practice levels, anti-patterns")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const payload = {
+        techTypes: Object.values(TECH_TYPES),
+        practiceLevels: Object.values(PRACTICE_LEVELS),
+        antiPatterns: Object.values(ANTI_PATTERNS),
+      };
+      if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+      } else {
+        logger.log(
+          `  ${chalk.bold("Tech types:")}      ${payload.techTypes.join(", ")}`,
+        );
+        logger.log(
+          `  ${chalk.bold("Practice levels:")} ${payload.practiceLevels.join(", ")}`,
+        );
+        logger.log(
+          `  ${chalk.bold("Anti-patterns:")}   ${payload.antiPatterns.join(", ")}`,
+        );
+      }
+    });
+
+  tech
+    .command("analyze [path]")
+    .description("Analyze tech stack of a project directory")
+    .option("--json", "Output as JSON")
+    .action(async (projectPath, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const profile = analyzeTechStack(db, projectPath || process.cwd());
+        if (options.json) {
+          console.log(JSON.stringify(profile, null, 2));
+        } else {
+          logger.success("Tech stack analyzed");
+          logger.log(`  ${chalk.bold("Path:")}         ${profile.projectPath}`);
+          logger.log(
+            `  ${chalk.bold("Languages:")}    ${profile.languages.join(", ") || "(none)"}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Frameworks:")}   ${profile.frameworks.join(", ") || "(none)"}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Databases:")}    ${profile.databases.join(", ") || "(none)"}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Tools:")}        ${profile.tools.join(", ") || "(none)"}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Total deps:")}   ${profile.totalDependencies}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  tech
+    .command("profile [path]")
+    .description("Show the last analyzed profile for a path")
+    .option("--json", "Output as JSON")
+    .action(async (projectPath, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const profile = getProfile(projectPath || process.cwd());
+        if (!profile) {
+          logger.info("No profile cached. Run `tech analyze` first.");
+        } else if (options.json) {
+          console.log(JSON.stringify(profile, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.bold("Languages:")}  ${profile.languages.join(", ")}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Frameworks:")} ${profile.frameworks.join(", ") || "(none)"}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Libraries:")}  ${profile.libraries.length}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  tech
+    .command("detect <file>")
+    .description("Detect anti-patterns in a single file")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      try {
+        const r = detectAntiPatterns(file);
+        if (options.json) {
+          console.log(JSON.stringify(r, null, 2));
+        } else if (r.totalFindings === 0) {
+          logger.success(
+            `No anti-patterns detected (${r.lines} lines, ${r.functionCount} funcs)`,
+          );
+        } else {
+          logger.warn(`${r.totalFindings} anti-pattern finding(s):`);
+          for (const f of r.findings) {
+            logger.log(
+              `  ${chalk.yellow(f.type.padEnd(22))} [${f.severity}] ${f.detail}`,
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  tech
+    .command("practice <tech-type> <tech-name> <pattern> <level>")
+    .description(
+      "Record a learned practice (tech-type: language|framework|library|database|tool|pattern)",
+    )
+    .option("-d, --description <text>", "Description", "")
+    .option("-s, --score <n>", "Score 0..1", parseFloat, 0)
+    .option("--source <tag>", "Source tag", "manual")
+    .option("--json", "Output as JSON")
+    .action(async (techType, techName, patternName, level, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const p = recordPractice(db, {
+          techType,
+          techName,
+          patternName,
+          level,
+          description: options.description,
+          score: options.score,
+          source: options.source,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(p, null, 2));
+        } else {
+          logger.success("Practice recorded");
+          logger.log(
+            `  ${chalk.bold("ID:")}      ${chalk.cyan(p.practiceId.slice(0, 8))}`,
+          );
+          logger.log(`  ${chalk.bold("Tech:")}    ${p.techType}/${p.techName}`);
+          logger.log(`  ${chalk.bold("Pattern:")} ${p.patternName}`);
+          logger.log(`  ${chalk.bold("Level:")}   ${p.level}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  tech
+    .command("practices")
+    .description("List recorded practices")
+    .option("-t, --type <type>", "Filter by tech type")
+    .option("-n, --name <name>", "Filter by tech name")
+    .option("-l, --level <level>", "Filter by level")
+    .option("--limit <n>", "Maximum entries", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = listPractices({
+          techType: options.type,
+          techName: options.name,
+          level: options.level,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No practices recorded.");
+        } else {
+          for (const p of rows) {
+            logger.log(
+              `  ${chalk.cyan(p.practiceId.slice(0, 8))} ${p.techType.padEnd(10)} ${p.techName.padEnd(14)} [${p.level.padEnd(12)}] ${p.patternName}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  tech
+    .command("recommend")
+    .description("Recommend practices based on the analyzed stack")
+    .option("--limit <n>", "Maximum entries", parseInt, 20)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const r = getRecommendations({ limit: options.limit });
+        if (options.json) {
+          console.log(JSON.stringify(r, null, 2));
+        } else if (r.recommendations.length === 0) {
+          logger.info(
+            r.message ||
+              `${r.totalPractices} practice(s) stored; 0 match the analyzed stack.`,
+          );
+        } else {
+          logger.log(
+            `  ${chalk.bold("Matches:")} ${r.totalMatches}/${r.totalPractices}`,
+          );
+          for (const p of r.recommendations) {
+            logger.log(
+              `  ${chalk.cyan(p.techName.padEnd(14))} [${p.level.padEnd(12)}] ${p.patternName}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}