depwire-cli 0.9.19 → 0.9.21

package/dist/index.js

@@ -1,37 +1,40 @@
 #!/usr/bin/env node
 import {
-  analyzeDeadCode,
-  buildGraph,
-  calculateHealthScore,
   checkoutCommit,
   createEmptyState,
   createSnapshot,
-  findProjectRoot,
-  generateDocs,
-  getArchitectureSummary,
   getCommitLog,
   getCurrentBranch,
-  getHealthTrend,
-  getImpact,
   isGitRepo,
   loadSnapshot,
-  parseProject,
   popStash,
   prepareVizData,
   restoreOriginal,
   sampleCommits,
   saveSnapshot,
-  searchSymbols,
   startMcpServer,
   startVizServer,
   stashChanges,
   updateFileInGraph,
   watchProject
-} from "./chunk-S3NZMIIU.js";
+} from "./chunk-XBCQPU63.js";
+import {
+  SimulationEngine,
+  analyzeDeadCode,
+  buildGraph,
+  calculateHealthScore,
+  findProjectRoot,
+  generateDocs,
+  getArchitectureSummary,
+  getHealthTrend,
+  getImpact,
+  parseProject,
+  searchSymbols
+} from "./chunk-QHVWDUSX.js";
 
 // src/index.ts
 import { Command } from "commander";
-import { resolve, dirname as dirname2, join as join3 } from "path";
+import { resolve as resolve2, dirname as dirname2, join as join3 } from "path";
 import { writeFileSync, readFileSync as readFileSync2, existsSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -302,10 +305,10 @@ async function findAvailablePort(startPort) {
   const net = await import("net");
   for (let attempt = 0; attempt < 10; attempt++) {
     const testPort = startPort + attempt;
-    const isAvailable = await new Promise((resolve2) => {
-      const server = net.createServer().once("error", () => resolve2(false)).once("listening", () => {
+    const isAvailable = await new Promise((resolve3) => {
+      const server = net.createServer().once("error", () => resolve3(false)).once("listening", () => {
         server.close();
-        resolve2(true);
+        resolve3(true);
       }).listen(testPort, "127.0.0.1");
     });
     if (isAvailable) {
@@ -346,13 +349,13 @@ async function startTemporalServer(snapshots, projectRoot, preferredPort = 3334)
       console.log("  (Could not open browser automatically)");
     });
   });
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     server.on("error", reject);
     process.on("SIGINT", () => {
       console.log("\n\nShutting down temporal server...");
       server.close(() => {
         console.log("Server stopped");
-        resolve2();
+        resolve3();
         process.exit(0);
       });
     });
@@ -496,6 +499,138 @@ async function trackCommand(command, version = "unknown") {
   });
 }
 
+// src/commands/whatif.ts
+import { resolve } from "path";
+import chalk from "chalk";
+async function whatif(dir, options) {
+  if (!options.simulate) {
+    console.log("Usage: depwire whatif [dir] --simulate <action> --target <file> [options]");
+    console.log("");
+    console.log("Actions: move, delete, rename, split, merge");
+    console.log("");
+    console.log("Run without --simulate to open interactive browser UI (Phase B)");
+    return;
+  }
+  const validActions = ["move", "delete", "rename", "split", "merge"];
+  if (!validActions.includes(options.simulate)) {
+    console.error(chalk.red(`Invalid action: ${options.simulate}. Must be one of: ${validActions.join(", ")}`));
+    process.exit(1);
+  }
+  if (!options.target) {
+    console.error(chalk.red("--target is required for all simulation actions"));
+    process.exit(1);
+  }
+  const action = buildAction(options);
+  const projectRoot = dir === "." ? findProjectRoot() : resolve(dir);
+  console.log(`Parsing project: ${projectRoot}`);
+  const parsedFiles = await parseProject(projectRoot);
+  const graph = buildGraph(parsedFiles);
+  console.log(`Built graph: ${graph.order} symbols, ${graph.size} edges`);
+  console.log("");
+  const engine = new SimulationEngine(graph);
+  try {
+    const result = engine.simulate(action);
+    printResult(result);
+  } catch (err) {
+    console.error(chalk.red(`Simulation failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+function buildAction(options) {
+  const type = options.simulate;
+  const target = options.target;
+  switch (type) {
+    case "move":
+      if (!options.destination) {
+        console.error(chalk.red("--destination is required for move action"));
+        process.exit(1);
+      }
+      return { type: "move", target, destination: options.destination };
+    case "delete":
+      return { type: "delete", target };
+    case "rename":
+      if (!options.newName) {
+        console.error(chalk.red("--new-name is required for rename action"));
+        process.exit(1);
+      }
+      return { type: "rename", target, newName: options.newName };
+    case "split":
+      if (!options.newFile) {
+        console.error(chalk.red("--new-file is required for split action"));
+        process.exit(1);
+      }
+      if (!options.symbols) {
+        console.error(chalk.red("--symbols is required for split action (comma-separated)"));
+        process.exit(1);
+      }
+      return {
+        type: "split",
+        target,
+        newFile: options.newFile,
+        symbols: options.symbols.split(",").map((s) => s.trim())
+      };
+    case "merge":
+      if (!options.source) {
+        console.error(chalk.red("--source is required for merge action"));
+        process.exit(1);
+      }
+      return { type: "merge", target, source: options.source };
+    default:
+      console.error(chalk.red(`Unknown action: ${type}`));
+      process.exit(1);
+  }
+}
+function printResult(result) {
+  const { action, healthDelta, diff } = result;
+  const line = "\u2500".repeat(45);
+  console.log(chalk.bold("What If Simulation"));
+  console.log(chalk.dim(line));
+  const actionStr = formatAction(action);
+  console.log(`${chalk.bold("Action:")}     ${actionStr}`);
+  console.log(chalk.dim(line));
+  const deltaSign = healthDelta.delta >= 0 ? "+" : "";
+  const deltaColor = healthDelta.improved ? chalk.green : healthDelta.delta === 0 ? chalk.yellow : chalk.red;
+  const deltaIcon = healthDelta.improved ? "\u2713 improved" : healthDelta.delta === 0 ? "\u2192 unchanged" : "\u2717 degraded";
+  console.log(
+    `${chalk.bold("Health Score:")}    ${healthDelta.before} \u2192 ${healthDelta.after}  ${deltaColor(`(${deltaSign}${healthDelta.delta} ${deltaIcon})`)}`
+  );
+  const changed = healthDelta.dimensionChanges.filter((d) => d.delta !== 0);
+  if (changed.length > 0) {
+    for (const d of changed) {
+      const dSign = d.delta >= 0 ? "+" : "";
+      const dColor = d.delta > 0 ? chalk.green : chalk.red;
+      console.log(`  ${chalk.dim("\u2022")} ${d.name}: ${d.before} \u2192 ${d.after} ${dColor(`(${dSign}${d.delta})`)}`);
+    }
+  }
+  console.log(`${chalk.bold("Affected Nodes:")}  ${diff.affectedNodes.length}`);
+  console.log(`${chalk.bold("Broken Imports:")}  ${diff.brokenImports.length}`);
+  if (diff.brokenImports.length > 0) {
+    for (const bi of diff.brokenImports) {
+      console.log(`  ${chalk.yellow("\u2022")} ${bi.file} ${bi.reason}`);
+    }
+  }
+  console.log(
+    `${chalk.bold("Circular Deps:")}   ${diff.circularDepsIntroduced.length} introduced, ${diff.circularDepsResolved.length} resolved`
+  );
+  console.log(`${chalk.bold("Added Edges:")}     ${diff.addedEdges.length}`);
+  console.log(`${chalk.bold("Removed Edges:")}   ${diff.removedEdges.length}`);
+  console.log(chalk.dim(line));
+}
+function formatAction(action) {
+  switch (action.type) {
+    case "move":
+      return `MOVE ${action.target} \u2192 ${action.destination}`;
+    case "delete":
+      return `DELETE ${action.target}`;
+    case "rename":
+      return `RENAME ${action.target} \u2192 ${action.newName}`;
+    case "split":
+      return `SPLIT ${action.target} \u2192 ${action.newFile} (${action.symbols.join(", ")})`;
+    case "merge":
+      return `MERGE ${action.source} \u2192 ${action.target}`;
+  }
+}
+
 // src/index.ts
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
@@ -507,7 +642,7 @@ program.command("parse").description("Parse a TypeScript project and build depen
   trackCommand("parse", packageJson.version);
   const startTime = Date.now();
   try {
-    const projectRoot = directory ? resolve(directory) : findProjectRoot();
+    const projectRoot = directory ? resolve2(directory) : findProjectRoot();
     console.log(`Parsing project: ${projectRoot}`);
     const parsedFiles = await parseProject(projectRoot, {
       exclude: options.exclude,
@@ -546,7 +681,7 @@ Orphan Files (no cross-references): ${summary.orphanFiles.length}`);
 program.command("query").description("Query impact analysis for a symbol").argument("<directory>", "Project directory").argument("<symbol-name>", "Symbol name to query").action(async (directory, symbolName) => {
   trackCommand("query", packageJson.version);
   try {
-    const projectRoot = resolve(directory);
+    const projectRoot = resolve2(directory);
     const cacheFile = "depwire-output.json";
     let graph;
     if (existsSync(cacheFile)) {
@@ -595,7 +730,7 @@ Total Transitive Dependents: ${impact.transitiveDependents.length}`);
 program.command("viz").description("Launch interactive arc diagram visualization").argument("[directory]", "Project directory to visualize (defaults to current directory or auto-detected project root)").option("-p, --port <number>", "Server port", "3333").option("--no-open", "Don't auto-open browser").option("--exclude <patterns...>", 'Glob patterns to exclude (e.g., "**/*.test.*" "dist/**")').option("--verbose", "Show detailed parsing progress").action(async (directory, options) => {
   trackCommand("viz", packageJson.version);
   try {
-    const projectRoot = directory ? resolve(directory) : findProjectRoot();
+    const projectRoot = directory ? resolve2(directory) : findProjectRoot();
     console.log(`Parsing project: ${projectRoot}`);
     const parsedFiles = await parseProject(projectRoot, {
       exclude: options.exclude,
@@ -618,7 +753,7 @@ program.command("viz").description("Launch interactive arc diagram visualization
 program.command("temporal").description("Visualize how the dependency graph evolved over git history").argument("[directory]", "Project directory to analyze (defaults to current directory or auto-detected project root)").option("--commits <number>", "Number of commits to sample", "20").option("--strategy <type>", "Sampling strategy: even, weekly, monthly", "even").option("-p, --port <number>", "Server port", "3334").option("--output <path>", "Save snapshots to custom path (default: .depwire/temporal/)").option("--verbose", "Show progress for each commit being parsed").option("--stats", "Show summary statistics at end").action(async (directory, options) => {
   trackCommand("temporal", packageJson.version);
   try {
-    const projectRoot = directory ? resolve(directory) : findProjectRoot();
+    const projectRoot = directory ? resolve2(directory) : findProjectRoot();
     await runTemporalAnalysis(projectRoot, {
       commits: parseInt(options.commits, 10),
       strategy: options.strategy,
@@ -638,7 +773,7 @@ program.command("mcp").description("Start MCP server for AI coding tools").argum
     const state = createEmptyState();
     let projectRootToConnect = null;
     if (directory) {
-      projectRootToConnect = resolve(directory);
+      projectRootToConnect = resolve2(directory);
     } else {
       const detectedRoot = findProjectRoot();
       const cwd = process.cwd();
@@ -699,8 +834,8 @@ program.command("docs").description("Generate comprehensive codebase documentati
   trackCommand("docs", packageJson.version);
   const startTime = Date.now();
   try {
-    const projectRoot = directory ? resolve(directory) : findProjectRoot();
-    const outputDir = options.output ? resolve(options.output) : join3(projectRoot, ".depwire");
+    const projectRoot = directory ? resolve2(directory) : findProjectRoot();
+    const outputDir = options.output ? resolve2(options.output) : join3(projectRoot, ".depwire");
     const includeList = options.include.split(",").map((s) => s.trim());
     const onlyList = options.only ? options.only.split(",").map((s) => s.trim()) : void 0;
     if (options.gitignore === void 0 && !existsSyncNode(outputDir)) {
@@ -762,11 +897,11 @@ async function promptGitignore() {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question("Add .depwire/ to .gitignore? [Y/n] ", (answer) => {
       rl.close();
       const normalized = answer.trim().toLowerCase();
-      resolve2(normalized === "" || normalized === "y" || normalized === "yes");
+      resolve3(normalized === "" || normalized === "y" || normalized === "yes");
     });
   });
 }
@@ -796,7 +931,7 @@ ${pattern}
 program.command("health").description("Analyze dependency architecture health (0-100 score)").argument("[directory]", "Project directory to analyze (defaults to current directory or auto-detected project root)").option("--json", "Output as JSON").option("--verbose", "Show detailed breakdown").action(async (directory, options) => {
   trackCommand("health", packageJson.version);
   try {
-    const projectRoot = directory ? resolve(directory) : findProjectRoot();
+    const projectRoot = directory ? resolve2(directory) : findProjectRoot();
     const startTime = Date.now();
     const parsedFiles = await parseProject(projectRoot);
     const graph = buildGraph(parsedFiles);
@@ -820,7 +955,7 @@ program.command("health").description("Analyze dependency architecture health (0
 program.command("dead-code").description("Identify dead code - symbols defined but never referenced").argument("[directory]", "Project directory to analyze (defaults to current directory or auto-detected project root)").option("--confidence <level>", "Minimum confidence level to show: high, medium, low (default: medium)", "medium").option("--json", "Output as JSON (for CI/automation)").option("--verbose", "Show detailed info for each dead symbol").option("--stats", "Show summary statistics").option("--include-tests", "Include test files in analysis").option("--include-low", "Shortcut for --confidence low").option("--debug", "Show debug information (exclusion stats)").action(async (directory, options) => {
   trackCommand("dead-code", packageJson.version);
   try {
-    const projectRoot = directory ? resolve(directory) : findProjectRoot();
+    const projectRoot = directory ? resolve2(directory) : findProjectRoot();
     const startTime = Date.now();
     const parsedFiles = await parseProject(projectRoot);
     const graph = buildGraph(parsedFiles);
@@ -847,4 +982,13 @@ Analysis completed in ${(totalTime / 1e3).toFixed(2)}s
     process.exit(1);
   }
 });
+program.command("whatif").description("Simulate architectural changes before touching code").argument("[directory]", "Project directory (defaults to auto-detected project root)").option("--simulate <action>", "Action to simulate: move, delete, rename, split, merge").option("--target <file>", "File to apply the action to").option("--destination <file>", "Destination path (for move action)").option("--new-name <name>", "New name (for rename action)").option("--source <file>", "Source file (for merge action)").option("--new-file <file>", "New file path (for split action)").option("--symbols <symbols>", "Comma-separated symbol names (for split action)").action(async (directory, options) => {
+  trackCommand("whatif", packageJson.version);
+  try {
+    await whatif(directory || ".", options);
+  } catch (err) {
+    console.error("Error running simulation:", err);
+    process.exit(1);
+  }
+});
 program.parse();

package/dist/mcpb-entry.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import {
-  buildGraph,
   createEmptyState,
-  parseProject,
   startMcpServer,
   updateFileInGraph,
   watchProject
-} from "./chunk-S3NZMIIU.js";
+} from "./chunk-XBCQPU63.js";
+import {
+  buildGraph,
+  parseProject
+} from "./chunk-QHVWDUSX.js";
 
 // src/mcpb-entry.ts
 import { resolve } from "path";

package/dist/sdk.d.ts

@@ -0,0 +1,237 @@
+import { DirectedGraph } from 'graphology';
+
+type SymbolKind = 'function' | 'class' | 'variable' | 'constant' | 'type_alias' | 'interface' | 'enum' | 'import' | 'export' | 'method' | 'property' | 'decorator' | 'module';
+interface SymbolNode {
+    id: string;
+    name: string;
+    kind: SymbolKind;
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    exported: boolean;
+    scope?: string;
+}
+type EdgeKind = 'imports' | 'calls' | 'extends' | 'implements' | 'inherits' | 'decorates' | 'references' | 'type_references';
+interface SymbolEdge {
+    source: string;
+    target: string;
+    kind: EdgeKind;
+    filePath: string;
+    line: number;
+}
+interface ParsedFile {
+    filePath: string;
+    symbols: SymbolNode[];
+    edges: SymbolEdge[];
+}
+
+/**
+ * SECURITY: All parser operations are READ-ONLY.
+ * Depwire never writes to, modifies, or deletes any file in the user's project.
+ * The only file system writes are to os.tmpdir() for cloned repos.
+ */
+
+declare function parseProject(projectRoot: string, options?: {
+    exclude?: string[];
+    verbose?: boolean;
+}): Promise<ParsedFile[]>;
+
+declare function buildGraph(parsedFiles: ParsedFile[]): DirectedGraph;
+
+/**
+ * Health Score Type Definitions
+ */
+interface HealthDimension {
+    name: string;
+    score: number;
+    weight: number;
+    grade: string;
+    details: string;
+    metrics: Record<string, number | string>;
+}
+interface HealthReport {
+    overall: number;
+    grade: string;
+    dimensions: HealthDimension[];
+    summary: string;
+    recommendations: string[];
+    projectStats: {
+        files: number;
+        symbols: number;
+        edges: number;
+        languages: Record<string, number>;
+    };
+    timestamp: string;
+}
+
+/**
+ * Calculate the overall health score for a project
+ */
+declare function calculateHealthScore(graph: DirectedGraph, projectRoot: string): HealthReport;
+
+type ConfidenceLevel = "high" | "medium" | "low";
+interface DeadSymbol {
+    name: string;
+    kind: string;
+    file: string;
+    line: number;
+    exported: boolean;
+    dependents: number;
+    confidence: ConfidenceLevel;
+    reason: string;
+}
+interface DeadCodeReport {
+    totalSymbols: number;
+    deadSymbols: number;
+    deadPercentage: number;
+    byConfidence: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+    symbols: DeadSymbol[];
+}
+interface DeadCodeOptions {
+    confidence: ConfidenceLevel;
+    includeTests: boolean;
+    verbose: boolean;
+    stats: boolean;
+    json: boolean;
+    debug: boolean;
+}
+
+declare function analyzeDeadCode(graph: DirectedGraph, projectRoot: string, options?: Partial<DeadCodeOptions>): DeadCodeReport;
+
+interface GeneratorOptions {
+    outputDir: string;
+    format: 'markdown' | 'json';
+    include: string[];
+    update: boolean;
+    only?: string[];
+    verbose: boolean;
+    stats: boolean;
+}
+interface GenerationResult {
+    success: boolean;
+    generated: string[];
+    errors: string[];
+    stats?: {
+        totalTime: number;
+        filesGenerated: number;
+    };
+}
+/**
+ * Main documentation generator
+ */
+declare function generateDocs(graph: DirectedGraph, projectRoot: string, version: string, parseTime: number, options: GeneratorOptions): Promise<GenerationResult>;
+
+declare function getImpact(graph: DirectedGraph, symbolId: string): {
+    directDependents: SymbolNode[];
+    transitiveDependents: SymbolNode[];
+    affectedFiles: string[];
+};
+declare function searchSymbols(graph: DirectedGraph, query: string): SymbolNode[];
+declare function getArchitectureSummary(graph: DirectedGraph): {
+    fileCount: number;
+    symbolCount: number;
+    edgeCount: number;
+    mostConnectedFiles: {
+        filePath: string;
+        connections: number;
+    }[];
+    orphanFiles: string[];
+};
+
+type SimulationAction = {
+    type: 'move';
+    target: string;
+    destination: string;
+} | {
+    type: 'delete';
+    target: string;
+} | {
+    type: 'rename';
+    target: string;
+    newName: string;
+} | {
+    type: 'split';
+    target: string;
+    newFile: string;
+    symbols: string[];
+} | {
+    type: 'merge';
+    target: string;
+    source: string;
+};
+interface SimulationResult {
+    action: SimulationAction;
+    originalGraph: GraphSnapshot;
+    simulatedGraph: GraphSnapshot;
+    diff: GraphDiff;
+    healthDelta: HealthDelta;
+}
+interface GraphSnapshot {
+    nodeCount: number;
+    edgeCount: number;
+    healthScore: number;
+}
+interface GraphDiff {
+    addedEdges: EdgeInfo[];
+    removedEdges: EdgeInfo[];
+    affectedNodes: string[];
+    brokenImports: BrokenImport[];
+    circularDepsIntroduced: string[][];
+    circularDepsResolved: string[][];
+}
+interface HealthDelta {
+    before: number;
+    after: number;
+    delta: number;
+    improved: boolean;
+    dimensionChanges: DimensionChange[];
+}
+interface DimensionChange {
+    name: string;
+    before: number;
+    after: number;
+    delta: number;
+}
+interface BrokenImport {
+    file: string;
+    importedSymbol: string;
+    reason: string;
+}
+interface EdgeInfo {
+    source: string;
+    target: string;
+    kind?: string;
+}
+declare class SimulationEngine {
+    private readonly original;
+    constructor(graph: DirectedGraph);
+    simulate(action: SimulationAction): SimulationResult;
+    private applyMove;
+    private applyDelete;
+    private applyRename;
+    private applySplit;
+    private applyMerge;
+    private computeDiff;
+    private collectEdges;
+    private edgeKey;
+    private detectCycles;
+    private computeHealthScore;
+}
+
+/**
+ * depwire-cli SDK — Public API Surface
+ *
+ * This is the ONLY file the cloud (Railway parser) should import from.
+ * Never import from internal paths like depwire-cli/dist/graph/index.js.
+ *
+ * Rule: if the cloud needs something not exported here, add it here —
+ * do not reach into internal paths.
+ */
+/** Current SDK version — matches depwire-cli npm version */
+declare const DepwireSDKVersion: string;
+
+export { type BrokenImport, DepwireSDKVersion, type GraphDiff, type HealthDelta, type SimulationAction, SimulationEngine, type SimulationResult, analyzeDeadCode, buildGraph, calculateHealthScore, generateDocs, getArchitectureSummary, getImpact, parseProject, searchSymbols };

package/dist/sdk.js

@@ -0,0 +1,32 @@
+import {
+  SimulationEngine,
+  analyzeDeadCode,
+  buildGraph,
+  calculateHealthScore,
+  generateDocs,
+  getArchitectureSummary,
+  getImpact,
+  parseProject,
+  searchSymbols
+} from "./chunk-QHVWDUSX.js";
+
+// src/sdk.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var packageJson = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+var DepwireSDKVersion = packageJson.version;
+export {
+  DepwireSDKVersion,
+  SimulationEngine,
+  analyzeDeadCode,
+  buildGraph,
+  calculateHealthScore,
+  generateDocs,
+  getArchitectureSummary,
+  getImpact,
+  parseProject,
+  searchSymbols
+};

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "depwire-cli",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "description": "The missing context layer for AI coding assistants. Dependency graph, MCP server, architecture health, dead code detection.",
   "type": "module",
   "bin": {
     "depwire": "dist/index.js"
   },
+  "exports": {
+    ".": "./dist/index.js",
+    "./sdk": "./dist/sdk.js"
+  },
   "scripts": {
-    "build": "tsup src/index.ts src/mcpb-entry.ts --format esm --dts --clean && npm run copy-static",
+    "build": "tsup src/index.ts src/mcpb-entry.ts src/sdk.ts --format esm --dts --clean && npm run copy-static",
     "copy-static": "mkdir -p dist/viz/public dist/parser/grammars && cp -r src/viz/public/* dist/viz/public/ && cp src/parser/grammars/*.wasm dist/parser/grammars/",
     "dev": "tsup src/index.ts --format esm --watch",
     "start": "node dist/index.js",
-    "build:mcpb": "npm run build && ./scripts/build-mcpb.sh"
+    "build:mcpb": "npm run build && ./scripts/build-mcpb.sh",
+    "postversion": "node -e \"const fs=require('fs');const p=JSON.parse(fs.readFileSync('./package.json','utf8'));const s=JSON.parse(fs.readFileSync('./server.json','utf8'));s.version=p.version;s.packages[0].version=p.version;fs.writeFileSync('./server.json',JSON.stringify(s,null,2)+'\\n');console.log('server.json updated to '+p.version);\" && git add server.json"
   },
   "keywords": [
     "typescript",
@@ -28,7 +33,14 @@
     "impact-analysis",
     "refactoring",
     "arc-diagram",
-    "cross-reference"
+    "cross-reference",
+    "whatif",
+    "simulation",
+    "architectural-simulation",
+    "what-if-analysis",
+    "refactor-simulation",
+    "blast-radius",
+    "deterministic-graph"
   ],
   "author": "Atef Ataya (https://www.youtube.com/@atefataya)",
   "license": "BUSL-1.1",