@learnrudi/cli 1.9.12 → 1.10.0

package/README.md

@@ -1,206 +1,263 @@
 # RUDI CLI
 
-Universal tool manager for MCP stacks, CLI tools, runtimes, and AI agents.
+A universal tool manager for MCP stacks, CLI tools, runtimes, and AI agents.
 
-## Install
+RUDI provides a unified installation and management system for:
+- **MCP Stacks** - Model Context Protocol servers for Claude, Codex, and Gemini
+- **CLI Tools** - Any npm package or upstream binary (ffmpeg, ripgrep, etc.)
+- **Runtimes** - Node.js, Python, Deno, Bun
+- **AI Agents** - Claude Code, Codex CLI, Gemini CLI
+
+## Installation
 
 ```bash
-npm i -g @learnrudi/cli
+npm install -g @learnrudi/cli
 ```
 
-Requires Node.js 18+. The postinstall step bootstraps `~/.rudi` and creates shims.
+Requires Node.js 18 or later. The installer creates `~/.rudi/` and adds shims to `~/.rudi/bins/`.
 
-## Quick Start
+Add to your shell profile (`.bashrc`, `.zshrc`, or `.profile`):
 
 ```bash
-# Install any npm CLI tool
-rudi install npm:typescript
-rudi install npm:@stripe/cli
-rudi install npm:vercel
+export PATH="$HOME/.rudi/bins:$PATH"
+```
 
-# Install curated stacks and tools
-rudi install slack
-rudi install binary:ffmpeg
-rudi install binary:supabase
+## Core Concepts
 
-# All tools available via ~/.rudi/bins/
-tsc --version
-ffmpeg -version
-supabase --version
+### Shim-Based Architecture
 
-# Configure secrets for stacks
-rudi secrets set SLACK_BOT_TOKEN "xoxb-your-token"
+Every tool installed through RUDI gets a wrapper script (shim) in `~/.rudi/bins/`. This provides:
 
-# Wire up your AI agents
-rudi integrate all
-```
+- Clean PATH integration without modifying system directories
+- Version isolation per package
+- Ownership tracking for clean uninstalls
+- Consistent invocation across different package sources
 
-## Features
+When you run `tsc`, the shell finds `~/.rudi/bins/tsc`, which delegates to the actual TypeScript installation at `~/.rudi/binaries/npm/typescript/node_modules/.bin/tsc`.
 
-### Universal Tool Installation
+### Package Sources
 
-RUDI supports multiple installation paths:
+RUDI supports three installation sources:
 
-```bash
-# Dynamic npm packages (any npm CLI)
-rudi install npm:cowsay
-rudi install npm:typescript
-rudi install npm:@railway/cli
+1. **Dynamic npm** (`npm:<package>`) - Any npm package with a `bin` field
+2. **Curated Registry** - Pre-configured stacks and binaries with documentation
+3. **Upstream Binaries** - Direct downloads from official sources
 
-# Curated registry (stacks and binaries with docs)
-rudi install slack              # MCP stack
-rudi install binary:ffmpeg      # Upstream binary
-rudi install binary:supabase    # npm-based CLI
+### Secret Management
 
-# All tools resolve through ~/.rudi/bins/
-```
+MCP stacks often require API keys and tokens. RUDI stores secrets in `~/.rudi/secrets.json` (mode 0600) and injects them as environment variables when running stacks. Secrets are never exposed in process listings or logs.
 
-### Shim-First Architecture
+## Usage
 
-Every installed tool gets a shim in `~/.rudi/bins/`:
+### Installing Packages
 
 ```bash
-# Add to your shell profile (.bashrc, .zshrc)
-export PATH="$HOME/.rudi/bins:$PATH"
+# Install any npm CLI tool
+rudi install npm:typescript       # Installs tsc, tsserver
+rudi install npm:@stripe/cli      # Installs stripe
+rudi install npm:vercel           # Installs vercel
 
-# Then use tools directly
-tsc --version      # → ~/.rudi/bins/tsc
-ffmpeg -version    # → ~/.rudi/bins/ffmpeg
-supabase --help    # → ~/.rudi/bins/supabase
+# Install from curated registry
+rudi install slack                # MCP stack for Slack
+rudi install binary:ffmpeg        # Upstream ffmpeg binary
+rudi install binary:supabase      # Supabase CLI
+
+# Install with scripts enabled (when needed)
+rudi install npm:puppeteer --allow-scripts
 ```
 
-### Security by Default
+### Listing Installed Packages
 
-npm packages run with `--ignore-scripts` by default:
+```bash
+rudi list                # All installed packages
+rudi list stacks         # MCP stacks only
+rudi list binaries       # CLI tools only
+rudi list runtimes       # Language runtimes
+rudi list agents         # AI agent CLIs
+```
+
+### Searching the Registry
 
 ```bash
-# Safe install (scripts skipped)
-rudi install npm:some-package
+rudi search pdf          # Search for packages
+rudi search --all        # List all available packages
+rudi search --stacks     # Filter to MCP stacks
+rudi search --binaries   # Filter to CLI tools
+```
 
-# If CLI fails, opt-in to scripts
-rudi install npm:some-package --allow-scripts
+### Managing Secrets
+
+```bash
+rudi secrets list                      # Show configured secrets (masked)
+rudi secrets set SLACK_BOT_TOKEN       # Set a secret (prompts for value)
+rudi secrets set OPENAI_API_KEY "sk-..." # Set with value
+rudi secrets remove SLACK_BOT_TOKEN    # Remove a secret
 ```
 
-## Commands
+### Integrating with AI Agents
 
 ```bash
-# Search and install
-rudi search <query>         # Search for packages
-rudi search --all           # List all packages
-rudi install <pkg>          # Install a package
-rudi install npm:<pkg>      # Install any npm CLI
-rudi remove <pkg>           # Remove a package
-
-# List and inspect
-rudi list [kind]            # List installed (stacks, binaries, agents)
-rudi pkg <id>               # Show package details and shim status
-rudi shims list             # List all shims
-rudi shims check            # Validate shim targets
-
-# Secrets and integration
-rudi secrets list           # Show configured secrets
-rudi secrets set <key>      # Set a secret
-rudi integrate <agent>      # Wire stack to agent config
-
-# Maintenance
-rudi update [pkg]           # Update packages
-rudi doctor                 # Check system health
+rudi integrate claude    # Add stacks to Claude Desktop config
+rudi integrate codex     # Add stacks to Codex config
+rudi integrate gemini    # Add stacks to Gemini config
+rudi integrate all       # Add to all detected agents
 ```
 
-## How It Works
+This modifies the agent's MCP configuration file (e.g., `~/Library/Application Support/Claude/claude_desktop_config.json`) to include your installed stacks with proper secret injection.
 
-### Installing a Package
+### Inspecting Packages
 
 ```bash
-rudi install npm:typescript
-```
+rudi pkg slack           # Show package details
+rudi pkg npm:typescript  # Show shims and paths
 
-1. Resolves package from npm registry
-2. Creates install directory at `~/.rudi/binaries/npm/typescript/`
-3. Runs `npm install typescript --ignore-scripts`
-4. Discovers binaries from package.json (`tsc`, `tsserver`)
-5. Creates wrapper shims in `~/.rudi/bins/`
-6. Records ownership in shim registry
+rudi shims list          # List all shims
+rudi shims check         # Validate shim targets exist
+```
 
-### Installing an MCP Stack
+### Maintenance
 
 ```bash
-rudi install slack
+rudi update              # Update all packages
+rudi update slack        # Update specific package
+rudi remove slack        # Uninstall a package
+rudi doctor              # Check system health
+```
+
+## Directory Structure
+
+```
+~/.rudi/
+├── bins/                 # Shims (add to PATH)
+│   ├── tsc              # → binaries/npm/typescript/...
+│   ├── ffmpeg           # → binaries/ffmpeg/...
+│   └── rudi-mcp         # MCP router for agents
+│
+├── stacks/               # MCP server installations
+│   ├── slack/
+│   │   ├── manifest.json
+│   │   ├── index.js
+│   │   └── node_modules/
+│   └── google-workspace/
+│
+├── binaries/             # CLI tool installations
+│   ├── ffmpeg/           # Upstream binary
+│   ├── supabase/         # npm-based CLI
+│   └── npm/              # Dynamic npm packages
+│       ├── typescript/
+│       └── vercel/
+│
+├── runtimes/             # Language runtimes
+│   ├── node/
+│   └── python/
+│
+├── agents/               # AI agent CLI installations
+│
+├── secrets.json          # API keys (mode 0600)
+├── shim-registry.json    # Shim ownership tracking
+└── rudi.db               # Local metadata database
 ```
 
-1. Downloads stack tarball from registry
-2. Extracts to `~/.rudi/stacks/slack/`
-3. Runs `npm install` for dependencies
-4. Shows which secrets need configuration
-5. Ready for `rudi integrate` to wire to agents
+## How MCP Integration Works
+
+When you run `rudi integrate claude`, RUDI:
 
-### Running MCP Stacks
+1. Reads the Claude Desktop config at `~/Library/Application Support/Claude/claude_desktop_config.json`
+2. Adds entries for each installed stack pointing to `~/.rudi/bins/rudi-mcp`
+3. Passes the stack ID as an argument
 
-When an AI agent runs a stack:
+When Claude invokes the MCP server:
 
-1. Agent config points to `~/.rudi/bins/rudi-mcp`
-2. RUDI loads secrets from `~/.rudi/secrets.json`
+1. `rudi-mcp` receives the stack ID
+2. Loads secrets from `~/.rudi/secrets.json`
 3. Injects secrets as environment variables
-4. Runs the MCP server with bundled runtime
+4. Spawns the actual MCP server process
+5. Proxies stdio between Claude and the server
 
-## Directory Structure
+This architecture means secrets stay local and are never written to agent config files.
+
+## Security Model
 
+### npm Package Installation
+
+By default, npm packages install with `--ignore-scripts` to prevent arbitrary code execution during install. If a package requires lifecycle scripts (e.g., native compilation), use:
+
+```bash
+rudi install npm:puppeteer --allow-scripts
 ```
-~/.rudi/
-├── bins/             # Shims for all tools (add to PATH)
-├── stacks/           # Installed MCP stacks
-├── binaries/         # Installed CLI tools
-│   ├── ffmpeg/       # Upstream binary
-│   ├── supabase/     # npm-based CLI
-│   └── npm/          # Dynamic npm packages
-│       ├── typescript/
-│       └── cowsay/
-├── runtimes/         # Bundled Node.js, Python
-├── agents/           # AI agent CLIs
-├── secrets.json      # Encrypted secrets
-├── shim-registry.json # Shim ownership tracking
-└── rudi.db           # Local database
+
+### Secret Storage
+
+Secrets are stored in `~/.rudi/secrets.json` with file permissions `0600` (owner read/write only). This matches the security model used by SSH, AWS CLI, and other credential stores.
+
+### Shim Isolation
+
+Each package installs to its own directory. Shims are thin wrappers that set up the environment and delegate to the real binary. This prevents packages from interfering with each other.
+
+## Available Stacks
+
+| Stack | Description | Required Secrets |
+|-------|-------------|------------------|
+| slack | Channels, messages, reactions | `SLACK_BOT_TOKEN` |
+| google-workspace | Gmail, Sheets, Docs, Drive | `GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET` |
+| notion-workspace | Pages, databases, search | `NOTION_API_KEY` |
+| github | Issues, PRs, repos, actions | `GITHUB_TOKEN` |
+| postgres | SQL queries | `DATABASE_URL` |
+| stripe | Payments, subscriptions | `STRIPE_SECRET_KEY` |
+| openai | DALL-E, Whisper, TTS | `OPENAI_API_KEY` |
+| google-ai | Gemini, Imagen | `GOOGLE_AI_API_KEY` |
+
+## Available Binaries
+
+| Binary | Description | Source |
+|--------|-------------|--------|
+| ffmpeg | Video/audio processing | Upstream |
+| ripgrep | Fast text search | Upstream |
+| supabase | Supabase CLI | npm |
+| vercel | Vercel CLI | npm |
+| uv | Python package manager | Upstream |
+
+## Troubleshooting
+
+### Command not found after install
+
+Ensure `~/.rudi/bins` is in your PATH:
+
+```bash
+echo $PATH | grep -q '.rudi/bins' && echo "OK" || echo "Add ~/.rudi/bins to PATH"
 ```
 
-## Available Packages
+### Shim points to missing target
 
-### MCP Stacks
+Run `rudi shims check` to validate all shims. If a target is missing, reinstall the package:
 
-| Stack | Description |
-|-------|-------------|
-| slack | Send messages, search channels, manage reactions |
-| google-workspace | Gmail, Sheets, Docs, Drive, Calendar |
-| notion-workspace | Pages, databases, search |
-| google-ai | Gemini, Imagen, Veo |
-| openai | DALL-E, Whisper, TTS, Sora |
-| postgres | PostgreSQL database queries |
-| video-editor | ffmpeg-based video editing |
-| github | Issues, PRs, repos, actions |
-| stripe | Payments, subscriptions, invoices |
+```bash
+rudi remove npm:typescript
+rudi install npm:typescript
+```
 
-### Binaries
+### MCP stack not appearing in agent
 
-| Binary | Description |
-|--------|-------------|
-| ffmpeg | Video/audio processing |
-| ripgrep | Fast search |
-| supabase | Supabase CLI |
-| vercel | Vercel CLI |
-| uv | Fast Python package manager |
+1. Check the stack is installed: `rudi list stacks`
+2. Run integration: `rudi integrate claude`
+3. Restart the AI agent application
 
-### Dynamic npm
+### Permission denied on secrets
 
-Any npm package with a `bin` field works:
+Ensure correct permissions:
 
 ```bash
-rudi install npm:typescript    # tsc, tsserver
-rudi install npm:cowsay        # cowsay, cowthink
-rudi install npm:@stripe/cli   # stripe
-rudi install npm:netlify-cli   # netlify
+chmod 600 ~/.rudi/secrets.json
 ```
 
 ## Links
 
-- Website: https://learnrudi.com
+- Documentation: https://learn-rudi.github.io/cli/
+- Repository: https://github.com/learn-rudi/cli
 - Registry: https://github.com/learn-rudi/registry
+- npm: https://www.npmjs.com/package/@learnrudi/cli
 - Issues: https://github.com/learn-rudi/cli/issues
+
+## License
+
+MIT

package/dist/index.cjs

@@ -1016,8 +1016,7 @@ async function resolvePackage(id) {
   if (id.startsWith("npm:")) {
     return resolveDynamicNpm(id);
   }
-  const normalizedId = id.includes(":") ? id : `stack:${id}`;
-  const pkg = await getPackage(normalizedId);
+  const pkg = await getPackage(id);
   if (!pkg) {
     throw new Error(`Package not found: ${id}`);
   }
@@ -17303,6 +17302,7 @@ __export(sqlite_exports, {
   clearEmbeddings: () => clearEmbeddings,
   deleteEmbedding: () => deleteEmbedding,
   ensureEmbeddingsSchema: () => ensureEmbeddingsSchema,
+  getAllEmbeddingStats: () => getAllEmbeddingStats,
   getEmbeddingStats: () => getEmbeddingStats,
   getErrorTurns: () => getErrorTurns,
   getMissingTurns: () => getMissingTurns,
@@ -17472,6 +17472,38 @@ function getEmbeddingStats(model) {
   }
   return stats;
 }
+function getAllEmbeddingStats() {
+  const db3 = getDb2();
+  const totalStmt = db3.prepare(`
+    SELECT COUNT(*) as count
+    FROM turns
+    WHERE (user_message IS NOT NULL AND length(trim(user_message)) > 0)
+       OR (assistant_response IS NOT NULL AND length(trim(assistant_response)) > 0)
+  `);
+  const total = totalStmt.get().count;
+  const statsStmt = db3.prepare(`
+    SELECT
+      status,
+      COUNT(*) as count
+    FROM turn_embeddings
+    GROUP BY status
+  `);
+  const stats = { total, done: 0, queued: 0, error: 0 };
+  for (const row of statsStmt.all()) {
+    stats[row.status] = row.count;
+  }
+  const modelsStmt = db3.prepare(`
+    SELECT model, dimensions, COUNT(*) as count
+    FROM turn_embeddings
+    WHERE status = 'done'
+    GROUP BY model, dimensions
+  `);
+  stats.models = {};
+  for (const row of modelsStmt.all()) {
+    stats.models[row.model] = { dimensions: row.dimensions, count: row.count };
+  }
+  return stats;
+}
 function deleteEmbedding(turnId) {
   const db3 = getDb2();
   db3.prepare("DELETE FROM turn_embeddings WHERE turn_id = ?").run(turnId);
@@ -35517,6 +35549,7 @@ function dbTables(flags) {
 }
 
 // src/commands/session.js
+var import_readline2 = require("readline");
 var embeddingsModule = null;
 async function getEmbeddings() {
   if (!embeddingsModule) {
@@ -35524,6 +35557,92 @@ async function getEmbeddings() {
   }
   return embeddingsModule;
 }
+async function confirm(message) {
+  const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${message} [Y/n] `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() !== "n");
+    });
+  });
+}
+async function ensureEmbeddingProvider(preferredProvider = "auto", options = {}) {
+  const { checkProviderStatus: checkProviderStatus2, getProvider: getProvider2 } = await getEmbeddings();
+  const status = await checkProviderStatus2();
+  if (preferredProvider === "openai") {
+    if (status.openai.configured) {
+      return await getProvider2("openai");
+    }
+    console.log("OpenAI not configured. Set OPENAI_API_KEY environment variable.");
+    return null;
+  }
+  try {
+    return await getProvider2("auto");
+  } catch {
+  }
+  if (status.openai.configured) {
+    console.log("\nOllama not available. OpenAI is configured.");
+    const useOpenAI = await confirm("Use OpenAI for embeddings? (costs ~$0.02/1M tokens)");
+    if (useOpenAI) {
+      return await getProvider2("openai");
+    }
+  }
+  console.log("\nNo embedding provider available.\n");
+  console.log("Options:");
+  console.log("  [1] Install Ollama (recommended - free, local, works offline)");
+  console.log("  [2] Use OpenAI (requires OPENAI_API_KEY)");
+  console.log("  [3] Cancel\n");
+  const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stdout });
+  const choice = await new Promise((resolve) => {
+    rl.question("Choice [1]: ", (answer) => {
+      rl.close();
+      resolve(answer || "1");
+    });
+  });
+  if (choice === "3" || choice.toLowerCase() === "cancel") {
+    return null;
+  }
+  if (choice === "2") {
+    if (!status.openai.configured) {
+      console.log("\nOpenAI not configured.");
+      console.log("Set: export OPENAI_API_KEY=your-key");
+      return null;
+    }
+    return await getProvider2("openai");
+  }
+  console.log("\nInstalling Ollama...");
+  try {
+    const { installPackage: installPackage2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
+    await installPackage2("runtime:ollama", {
+      onProgress: (p2) => {
+        if (p2.phase === "downloading") process.stdout.write("\r  Downloading...");
+        if (p2.phase === "extracting") process.stdout.write("\r  Installing...  ");
+      }
+    });
+    console.log("\r  \u2713 Ollama installed     ");
+    console.log("  Starting ollama serve...");
+    const { spawn: spawn4 } = await import("child_process");
+    const server = spawn4("ollama", ["serve"], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, HOME: process.env.HOME }
+    });
+    server.unref();
+    await new Promise((r2) => setTimeout(r2, 2e3));
+    console.log("  Pulling nomic-embed-text model (274MB)...");
+    const { execSync: execSync10 } = await import("child_process");
+    execSync10("ollama pull nomic-embed-text", { stdio: "inherit" });
+    console.log("  \u2713 Model ready\n");
+    return await getProvider2("ollama");
+  } catch (err) {
+    console.error("\nSetup failed:", err.message);
+    console.log("\nManual setup:");
+    console.log("  rudi install ollama");
+    console.log("  ollama serve");
+    console.log("  ollama pull nomic-embed-text");
+    return null;
+  }
+}
 async function cmdSession(args, flags) {
   const subcommand = args[0];
   switch (subcommand) {
@@ -35560,6 +35679,9 @@ async function cmdSession(args, flags) {
     case "setup":
       await sessionSetup(flags);
       break;
+    case "organize":
+      await sessionOrganize(flags);
+      break;
     default:
       console.log(`
 rudi session - Manage RUDI sessions
@@ -35579,6 +35701,9 @@ SEMANTIC SEARCH
   index [--embeddings] [--provider X]        Index sessions for semantic search
   similar <id> [--limit]                     Find similar sessions
 
+ORGANIZATION (batch operations)
+  organize [--dry-run] [--out plan.json]     Auto-organize sessions into projects
+
 OPTIONS
   --provider <name>     Filter by provider (claude, codex, gemini)
   --project <name>      Filter by project name
@@ -35926,8 +36051,12 @@ Found ${results.length} result(s) for "${query}":
 async function semanticSearch(query, options) {
   const { limit: limit2, format } = options;
   try {
-    const { createClient: createClient2, getProvider: getProvider2 } = await getEmbeddings();
-    const { provider, model } = await getProvider2("auto");
+    const { createClient: createClient2 } = await getEmbeddings();
+    const result = await ensureEmbeddingProvider("auto");
+    if (!result) {
+      return;
+    }
+    const { provider, model } = result;
     console.log(`Using ${provider.id} with ${model.name}`);
     const client = createClient2({ provider, model });
     const stats = client.getStats();
@@ -35976,18 +36105,25 @@ async function sessionIndex(flags) {
   const providerName = flags.provider || "auto";
   if (!flags.embeddings) {
     try {
-      const { createClient: createClient2, getProvider: getProvider2, store } = await getEmbeddings();
-      const model = { name: "text-embedding-3-small", dimensions: 1536 };
-      const stats = store.getEmbeddingStats(model);
+      const { store } = await getEmbeddings();
+      const stats = store.getAllEmbeddingStats();
       const pct = stats.total > 0 ? (stats.done / stats.total * 100).toFixed(1) : 0;
       console.log("\nEmbedding Index Status:");
       console.log(`  Total turns: ${stats.total}`);
       console.log(`  Indexed: ${stats.done} (${pct}%)`);
       console.log(`  Queued: ${stats.queued}`);
       console.log(`  Errors: ${stats.error}`);
-      console.log("\nTo index missing turns:");
-      console.log("  rudi session index --embeddings");
-      console.log("  rudi session index --embeddings --provider ollama");
+      if (Object.keys(stats.models).length > 0) {
+        console.log("\nIndexed by model:");
+        for (const [model, info] of Object.entries(stats.models)) {
+          console.log(`  ${model} (${info.dimensions}d): ${info.count} turns`);
+        }
+      }
+      if (stats.done < stats.total) {
+        console.log("\nTo index missing turns:");
+        console.log("  rudi session index --embeddings");
+        console.log("  rudi session index --embeddings --provider ollama");
+      }
     } catch (err) {
       console.log("Embedding status unavailable:", err.message);
     }
@@ -35995,8 +36131,12 @@ async function sessionIndex(flags) {
   }
   console.log("Indexing sessions for semantic search...\n");
   try {
-    const { createClient: createClient2, getProvider: getProvider2 } = await getEmbeddings();
-    const { provider, model } = await getProvider2(providerName);
+    const { createClient: createClient2 } = await getEmbeddings();
+    const providerResult = await ensureEmbeddingProvider(providerName);
+    if (!providerResult) {
+      return;
+    }
+    const { provider, model } = providerResult;
     console.log(`Provider: ${provider.id}`);
     console.log(`Model: ${model.name} (${model.dimensions}d)
 `);
@@ -36057,8 +36197,12 @@ async function sessionSimilar(args, flags) {
   const format = flags.format || "table";
   const providerName = flags.provider || "auto";
   try {
-    const { createClient: createClient2, getProvider: getProvider2 } = await getEmbeddings();
-    const { provider, model } = await getProvider2(providerName);
+    const { createClient: createClient2 } = await getEmbeddings();
+    const result = await ensureEmbeddingProvider(providerName);
+    if (!result) {
+      return;
+    }
+    const { provider, model } = result;
     const client = createClient2({ provider, model });
     const results = await client.findSimilar(turnId, { limit: limit2 });
     if (format === "json") {
@@ -36107,6 +36251,223 @@ async function sessionSetup(flags) {
     console.error("Setup error:", err.message);
   }
 }
+async function sessionOrganize(flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized.");
+    return;
+  }
+  const dryRun = flags["dry-run"] || flags.dryRun || true;
+  const outputFile = flags.out || flags.output || "organize-plan.json";
+  const threshold = parseFloat(flags.threshold) || 0.65;
+  const db3 = getDb();
+  console.log("\u2550".repeat(60));
+  console.log("Session Organization");
+  console.log("\u2550".repeat(60));
+  console.log(`Mode: ${dryRun ? "Dry run (preview only)" : "LIVE - will apply changes"}`);
+  console.log(`Output: ${outputFile}`);
+  console.log(`Similarity threshold: ${(threshold * 100).toFixed(0)}%`);
+  console.log("\u2550".repeat(60));
+  const sessions = db3.prepare(`
+    SELECT
+      s.id, s.provider, s.title, s.title_override, s.project_id, s.cwd,
+      s.turn_count, s.total_cost, s.created_at, s.last_active_at,
+      p.name as project_name
+    FROM sessions s
+    LEFT JOIN projects p ON s.project_id = p.id
+    WHERE s.status = 'active'
+    ORDER BY s.total_cost DESC
+  `).all();
+  console.log(`
+Analyzing ${sessions.length} sessions...
+`);
+  const projects = db3.prepare("SELECT id, name FROM projects").all();
+  const projectMap = new Map(projects.map((p2) => [p2.name.toLowerCase(), p2]));
+  console.log(`Existing projects: ${projects.map((p2) => p2.name).join(", ") || "(none)"}
+`);
+  const cwdGroups = /* @__PURE__ */ new Map();
+  for (const s2 of sessions) {
+    if (!s2.cwd) continue;
+    const match = s2.cwd.match(/\/([^/]+)$/);
+    const projectKey = match ? match[1] : "other";
+    if (!cwdGroups.has(projectKey)) {
+      cwdGroups.set(projectKey, []);
+    }
+    cwdGroups.get(projectKey).push(s2);
+  }
+  const genericTitlePatterns = [
+    /^(Imported|Agent|New|Untitled|Chat) Session$/i,
+    /^Session \d+$/i,
+    /^Untitled$/i,
+    /^[A-Z][a-z]+ [A-Z][a-z]+ [A-Z][a-z]+$/
+    // "Adjective Verb Noun" (Claude auto-generated)
+  ];
+  const sessionsNeedingTitles = sessions.filter((s2) => {
+    if (s2.title_override && s2.title_override !== s2.title) {
+      return false;
+    }
+    const title = s2.title || "";
+    return !title || genericTitlePatterns.some((p2) => p2.test(title));
+  });
+  console.log(`Sessions with generic titles: ${sessionsNeedingTitles.length}`);
+  const titleSuggestions = [];
+  for (const s2 of sessionsNeedingTitles.slice(0, 100)) {
+    const firstTurn = db3.prepare(`
+      SELECT user_message
+      FROM turns
+      WHERE session_id = ? AND user_message IS NOT NULL AND length(trim(user_message)) > 10
+      ORDER BY turn_number
+      LIMIT 1
+    `).get(s2.id);
+    if (firstTurn && firstTurn.user_message) {
+      const msg = firstTurn.user_message.trim();
+      let suggestedTitle = msg.split("\n")[0].slice(0, 60).trim();
+      const skipPatterns = [
+        /^\/[A-Za-z]/,
+        // Unix paths
+        /^<[a-z-]+>/,
+        // XML tags
+        /^[A-Z]:\\[A-Za-z]/,
+        // Windows paths
+        /^(cd|ls|cat|npm|node|git|rudi|pnpm|yarn)\s/i,
+        // Commands
+        /^[a-f0-9-]{8,}/i,
+        // UUIDs or hashes
+        /^https?:\/\//i,
+        // URLs
+        /^[>\*\-#\d\.]\s/,
+        // Markdown list/quote starts
+        /^(yes|no|ok|sure|y|n)$/i,
+        // Single word responses
+        /^[^a-zA-Z]*$/,
+        // No letters at all
+        /^\s*\[/,
+        // JSON/array starts
+        /^\s*\{/
+        // Object starts
+      ];
+      if (skipPatterns.some((p2) => p2.test(suggestedTitle))) {
+        continue;
+      }
+      const wordCount = suggestedTitle.split(/\s+/).length;
+      if (wordCount < 3) {
+        continue;
+      }
+      if (suggestedTitle.length > 50) {
+        suggestedTitle = suggestedTitle.slice(0, 47) + "...";
+      }
+      if (suggestedTitle && suggestedTitle.length > 10) {
+        titleSuggestions.push({
+          sessionId: s2.id,
+          currentTitle: s2.title || "(none)",
+          suggestedTitle,
+          cost: s2.total_cost,
+          confidence: "medium"
+          // Could add scoring later
+        });
+      }
+    }
+  }
+  const projectSuggestions = [];
+  const moveSuggestions = [];
+  const knownProjects = {
+    "studio": "Prompt Stack Studio",
+    "prompt-stack": "Prompt Stack Studio",
+    "RUDI": "RUDI",
+    "rudi": "RUDI",
+    "cli": "RUDI",
+    "registry": "RUDI",
+    "resonance": "Resonance",
+    "cloud": "Cloud"
+  };
+  for (const [cwdKey, cwdSessions] of cwdGroups) {
+    const projectName = knownProjects[cwdKey];
+    if (projectName && cwdSessions.length >= 2) {
+      const existingProject = projectMap.get(projectName.toLowerCase());
+      for (const s2 of cwdSessions) {
+        if (!s2.project_id || existingProject && s2.project_id !== existingProject.id) {
+          moveSuggestions.push({
+            sessionId: s2.id,
+            sessionTitle: s2.title_override || s2.title,
+            currentProject: s2.project_name || null,
+            suggestedProject: projectName,
+            reason: `Working directory: ${cwdKey}`,
+            cost: s2.total_cost
+          });
+        }
+      }
+      if (!existingProject && cwdSessions.length >= 3) {
+        projectSuggestions.push({
+          name: projectName,
+          sessionCount: cwdSessions.length,
+          totalCost: cwdSessions.reduce((sum, s2) => sum + (s2.total_cost || 0), 0)
+        });
+      }
+    }
+  }
+  const plan = {
+    version: "1.0",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dryRun,
+    threshold,
+    summary: {
+      totalSessions: sessions.length,
+      sessionsWithProjects: sessions.filter((s2) => s2.project_id).length,
+      sessionsNeedingTitles: sessionsNeedingTitles.length,
+      projectsToCreate: projectSuggestions.length,
+      movesToApply: moveSuggestions.length,
+      titlesToUpdate: titleSuggestions.length
+    },
+    actions: {
+      createProjects: projectSuggestions,
+      moveSessions: moveSuggestions.slice(0, 200),
+      // Limit batch size
+      updateTitles: titleSuggestions.slice(0, 100)
+      // Limit batch size
+    }
+  };
+  console.log("\n" + "\u2500".repeat(60));
+  console.log("PLAN SUMMARY");
+  console.log("\u2500".repeat(60));
+  console.log(`Sessions analyzed: ${plan.summary.totalSessions}`);
+  console.log(`Already in projects: ${plan.summary.sessionsWithProjects}`);
+  console.log(`
+Proposed actions:`);
+  console.log(`  Create projects: ${plan.summary.projectsToCreate}`);
+  console.log(`  Move sessions: ${plan.summary.movesToApply}`);
+  console.log(`  Update titles: ${plan.summary.titlesToUpdate}`);
+  if (projectSuggestions.length > 0) {
+    console.log("\nProjects to create:");
+    for (const p2 of projectSuggestions) {
+      console.log(`  \u2022 ${p2.name} (${p2.sessionCount} sessions, $${p2.totalCost.toFixed(2)})`);
+    }
+  }
+  if (moveSuggestions.length > 0) {
+    console.log("\nTop session moves:");
+    for (const m2 of moveSuggestions.slice(0, 10)) {
+      console.log(`  \u2022 "${m2.sessionTitle?.slice(0, 30) || m2.sessionId.slice(0, 8)}..." \u2192 ${m2.suggestedProject}`);
+    }
+    if (moveSuggestions.length > 10) {
+      console.log(`  ... and ${moveSuggestions.length - 10} more`);
+    }
+  }
+  if (titleSuggestions.length > 0) {
+    console.log("\nTop title updates:");
+    for (const t2 of titleSuggestions.slice(0, 5)) {
+      console.log(`  \u2022 "${t2.currentTitle?.slice(0, 20) || "(none)"}..." \u2192 "${t2.suggestedTitle.slice(0, 30)}..."`);
+    }
+    if (titleSuggestions.length > 5) {
+      console.log(`  ... and ${titleSuggestions.length - 5} more`);
+    }
+  }
+  const { writeFileSync: writeFileSync7 } = await import("fs");
+  writeFileSync7(outputFile, JSON.stringify(plan, null, 2));
+  console.log(`
+\u2713 Plan saved to: ${outputFile}`);
+  console.log("\nTo apply this plan:");
+  console.log(`  rudi apply ${outputFile}`);
+  console.log("\nTo review the full plan:");
+  console.log(`  cat ${outputFile} | jq .`);
+}
 
 // src/commands/import.js
 var import_fs17 = require("fs");
@@ -39256,6 +39617,371 @@ Lockfile: ${lockPath}`);
   }
 }
 
+// src/commands/apply.js
+var import_fs28 = require("fs");
+var import_path26 = require("path");
+var import_os10 = require("os");
+var import_crypto3 = require("crypto");
+async function cmdApply(args, flags) {
+  const planFile = args[0];
+  const force = flags.force;
+  const undoPlanId = flags.undo;
+  const only = flags.only;
+  if (undoPlanId) {
+    return undoPlan(undoPlanId);
+  }
+  if (!planFile) {
+    console.log(`
+rudi apply - Execute organization plans
+
+USAGE
+  rudi apply <plan.json>     Apply a plan file
+  rudi apply --undo <id>     Undo a previously applied plan
+
+OPTIONS
+  --force                    Skip confirmation prompts
+  --only <type>              Apply only specific operations:
+                               move    - session moves only
+                               rename  - title updates only
+                               project - project creation only
+
+EXAMPLES
+  rudi session organize --dry-run --out plan.json
+  rudi apply plan.json
+  rudi apply plan.json --only move      # Moves first (low regret)
+  rudi apply plan.json --only rename    # Renames second
+  rudi apply --undo plan-20260109-abc123
+`);
+    return;
+  }
+  if (!(0, import_fs28.existsSync)(planFile)) {
+    console.error(`Plan file not found: ${planFile}`);
+    process.exit(1);
+  }
+  if (!isDatabaseInitialized()) {
+    console.error("Database not initialized. Run: rudi db init");
+    process.exit(1);
+  }
+  let plan;
+  try {
+    plan = JSON.parse((0, import_fs28.readFileSync)(planFile, "utf-8"));
+  } catch (err) {
+    console.error(`Invalid plan file: ${err.message}`);
+    process.exit(1);
+  }
+  if (!plan.version || !plan.actions) {
+    console.error("Invalid plan format: missing version or actions");
+    process.exit(1);
+  }
+  console.log("\u2550".repeat(60));
+  console.log("Apply Organization Plan");
+  console.log("\u2550".repeat(60));
+  console.log(`Plan file: ${planFile}`);
+  console.log(`Created: ${plan.createdAt}`);
+  console.log("\u2550".repeat(60));
+  let { createProjects = [], moveSessions = [], updateTitles = [] } = plan.actions;
+  if (only) {
+    console.log(`
+Filter: --only ${only}`);
+    if (only === "move") {
+      createProjects = [];
+      updateTitles = [];
+    } else if (only === "rename") {
+      createProjects = [];
+      moveSessions = [];
+    } else if (only === "project") {
+      moveSessions = [];
+      updateTitles = [];
+    } else {
+      console.error(`Unknown filter: ${only}. Use: move, rename, project`);
+      process.exit(1);
+    }
+  }
+  console.log("\nActions to apply:");
+  console.log(`  Create projects: ${createProjects.length}`);
+  console.log(`  Move sessions: ${moveSessions.length}`);
+  console.log(`  Update titles: ${updateTitles.length}`);
+  const totalActions = createProjects.length + moveSessions.length + updateTitles.length;
+  if (totalActions === 0) {
+    console.log("\nNo actions to apply (filtered out or empty).");
+    return;
+  }
+  if (!force) {
+    console.log("\nThis will modify your database.");
+    console.log("Add --force to skip this confirmation.\n");
+    const readline3 = await import("readline");
+    const rl = readline3.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question("Apply this plan? (y/N): ", resolve);
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y") {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+  const db3 = getDb();
+  const planId = `plan-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "")}-${(0, import_crypto3.randomUUID)().slice(0, 6)}`;
+  const undoActions = [];
+  console.log(`
+Applying plan ${planId}...
+`);
+  if (createProjects.length > 0) {
+    console.log("Creating projects...");
+    const insertProject = db3.prepare(`
+      INSERT OR IGNORE INTO projects (id, provider, name, created_at)
+      VALUES (?, 'claude', ?, datetime('now'))
+    `);
+    for (const p2 of createProjects) {
+      const projectId = `proj-${p2.name.toLowerCase().replace(/\s+/g, "-")}`;
+      try {
+        insertProject.run(projectId, p2.name);
+        console.log(`  \u2713 Created: ${p2.name}`);
+        undoActions.push({ type: "deleteProject", projectId, name: p2.name });
+      } catch (err) {
+        console.log(`  \u26A0 Skipped (exists): ${p2.name}`);
+      }
+    }
+  }
+  if (moveSessions.length > 0) {
+    console.log("\nMoving sessions...");
+    const projectIds = /* @__PURE__ */ new Map();
+    const projects = db3.prepare("SELECT id, name FROM projects").all();
+    for (const p2 of projects) {
+      projectIds.set(p2.name.toLowerCase(), p2.id);
+    }
+    const updateSession = db3.prepare(`
+      UPDATE sessions SET project_id = ? WHERE id = ?
+    `);
+    let moved = 0;
+    for (const m2 of moveSessions) {
+      const projectId = projectIds.get(m2.suggestedProject.toLowerCase());
+      if (!projectId) {
+        console.log(`  \u26A0 Project not found: ${m2.suggestedProject}`);
+        continue;
+      }
+      const current = db3.prepare("SELECT project_id FROM sessions WHERE id = ?").get(m2.sessionId);
+      try {
+        updateSession.run(projectId, m2.sessionId);
+        moved++;
+        undoActions.push({
+          type: "moveSession",
+          sessionId: m2.sessionId,
+          fromProject: current?.project_id,
+          toProject: projectId
+        });
+      } catch (err) {
+        console.log(`  \u26A0 Failed: ${m2.sessionId} - ${err.message}`);
+      }
+    }
+    console.log(`  \u2713 Moved ${moved} sessions`);
+  }
+  if (updateTitles.length > 0) {
+    console.log("\nUpdating titles...");
+    const updateTitle = db3.prepare(`
+      UPDATE sessions SET title = ?, title_override = ? WHERE id = ?
+    `);
+    let updated = 0;
+    for (const t2 of updateTitles) {
+      const current = db3.prepare("SELECT title, title_override FROM sessions WHERE id = ?").get(t2.sessionId);
+      try {
+        updateTitle.run(t2.suggestedTitle, t2.suggestedTitle, t2.sessionId);
+        updated++;
+        undoActions.push({
+          type: "updateTitle",
+          sessionId: t2.sessionId,
+          fromTitle: current?.title,
+          fromTitleOverride: current?.title_override,
+          toTitle: t2.suggestedTitle
+        });
+      } catch (err) {
+        console.log(`  \u26A0 Failed: ${t2.sessionId} - ${err.message}`);
+      }
+    }
+    console.log(`  \u2713 Updated ${updated} titles`);
+  }
+  const undoDir = (0, import_path26.join)((0, import_os10.homedir)(), ".rudi", "plans");
+  const { mkdirSync: mkdirSync5 } = await import("fs");
+  try {
+    mkdirSync5(undoDir, { recursive: true });
+  } catch (e2) {
+  }
+  const undoFile = (0, import_path26.join)(undoDir, `${planId}.undo.json`);
+  const undoPlan = {
+    planId,
+    appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceFile: planFile,
+    actions: undoActions
+  };
+  (0, import_fs28.writeFileSync)(undoFile, JSON.stringify(undoPlan, null, 2));
+  console.log("\n" + "\u2550".repeat(60));
+  console.log("Plan applied successfully!");
+  console.log("\u2550".repeat(60));
+  console.log(`Plan ID: ${planId}`);
+  console.log(`Undo file: ${undoFile}`);
+  console.log(`
+To undo: rudi apply --undo ${planId}`);
+}
+
+// src/commands/project.js
+async function cmdProject(args, flags) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "list":
+    case "ls":
+      projectList(flags);
+      break;
+    case "create":
+    case "add":
+      projectCreate(args.slice(1), flags);
+      break;
+    case "rename":
+      projectRename(args.slice(1), flags);
+      break;
+    case "delete":
+    case "rm":
+      projectDelete(args.slice(1), flags);
+      break;
+    default:
+      console.log(`
+rudi project - Manage session projects
+
+COMMANDS
+  list                         List all projects
+  create <name>                Create a new project
+  rename <id> <new-name>       Rename a project
+  delete <id>                  Delete a project (sessions become unassigned)
+
+OPTIONS
+  --provider <name>            Provider (claude, codex, gemini). Default: claude
+
+EXAMPLES
+  rudi project list
+  rudi project create "RUDI CLI"
+  rudi project rename proj-rudi "RUDI Tooling"
+  rudi project delete proj-old
+`);
+  }
+}
+function projectList(flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized. Run: rudi db init");
+    return;
+  }
+  const db3 = getDb();
+  const provider = flags.provider;
+  let query = `
+    SELECT
+      p.id, p.provider, p.name, p.color, p.created_at,
+      COUNT(s.id) as session_count,
+      ROUND(SUM(s.total_cost), 2) as total_cost
+    FROM projects p
+    LEFT JOIN sessions s ON s.project_id = p.id
+  `;
+  if (provider) {
+    query += ` WHERE p.provider = '${provider}'`;
+  }
+  query += ` GROUP BY p.id ORDER BY total_cost DESC`;
+  const projects = db3.prepare(query).all();
+  if (projects.length === 0) {
+    console.log("No projects found.");
+    console.log('\nCreate one with: rudi project create "My Project"');
+    return;
+  }
+  console.log(`
+Projects (${projects.length}):
+`);
+  for (const p2 of projects) {
+    console.log(`${p2.name}`);
+    console.log(`  ID: ${p2.id}`);
+    console.log(`  Provider: ${p2.provider}`);
+    console.log(`  Sessions: ${p2.session_count || 0}`);
+    console.log(`  Total cost: $${p2.total_cost || 0}`);
+    console.log("");
+  }
+}
+function projectCreate(args, flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized. Run: rudi db init");
+    return;
+  }
+  const name = args.join(" ");
+  if (!name) {
+    console.log("Error: Project name required");
+    console.log('Usage: rudi project create "Project Name"');
+    return;
+  }
+  const provider = flags.provider || "claude";
+  const id = `proj-${name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "")}`;
+  const db3 = getDb();
+  try {
+    db3.prepare(`
+      INSERT INTO projects (id, provider, name, created_at)
+      VALUES (?, ?, ?, datetime('now'))
+    `).run(id, provider, name);
+    console.log(`
+Project created:`);
+    console.log(`  ID: ${id}`);
+    console.log(`  Name: ${name}`);
+    console.log(`  Provider: ${provider}`);
+  } catch (err) {
+    if (err.message.includes("UNIQUE")) {
+      console.log(`Error: Project "${name}" already exists for ${provider}`);
+    } else {
+      console.log(`Error: ${err.message}`);
+    }
+  }
+}
+function projectRename(args, flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized.");
+    return;
+  }
+  const [id, ...nameParts] = args;
+  const newName = nameParts.join(" ");
+  if (!id || !newName) {
+    console.log("Error: Project ID and new name required");
+    console.log('Usage: rudi project rename <id> "New Name"');
+    return;
+  }
+  const db3 = getDb();
+  const result = db3.prepare("UPDATE projects SET name = ? WHERE id = ?").run(newName, id);
+  if (result.changes === 0) {
+    console.log(`Project not found: ${id}`);
+    return;
+  }
+  console.log(`
+Project renamed to: ${newName}`);
+}
+function projectDelete(args, flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized.");
+    return;
+  }
+  const id = args[0];
+  if (!id) {
+    console.log("Error: Project ID required");
+    console.log("Usage: rudi project delete <id>");
+    return;
+  }
+  const db3 = getDb();
+  const project = db3.prepare("SELECT name FROM projects WHERE id = ?").get(id);
+  if (!project) {
+    console.log(`Project not found: ${id}`);
+    return;
+  }
+  const sessionsResult = db3.prepare("UPDATE sessions SET project_id = NULL WHERE project_id = ?").run(id);
+  db3.prepare("DELETE FROM projects WHERE id = ?").run(id);
+  console.log(`
+Project deleted: ${project.name}`);
+  if (sessionsResult.changes > 0) {
+    console.log(`Unassigned ${sessionsResult.changes} sessions`);
+  }
+}
+
 // src/index.js
 var VERSION2 = "2.0.0";
 async function main() {
@@ -39306,6 +40032,13 @@ async function main() {
       case "import":
         await cmdImport(args, flags);
         break;
+      case "apply":
+        await cmdApply(args, flags);
+        break;
+      case "project":
+      case "projects":
+        await cmdProject(args, flags);
+        break;
       case "doctor":
         await cmdDoctor(args, flags);
         break;

package/dist/packages-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "generated": "2026-01-09T20:10:12.259Z",
+  "generated": "2026-01-09T21:15:38.064Z",
   "packages": {
     "runtimes": [
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@learnrudi/cli",
-  "version": "1.9.12",
+  "version": "1.10.0",
   "description": "RUDI CLI - Install and manage MCP stacks, runtimes, and AI agents",
   "type": "module",
   "main": "dist/index.cjs",
@@ -12,18 +12,26 @@
     "scripts",
     "README.md"
   ],
+  "scripts": {
+    "start": "node src/index.js",
+    "prebuild": "node scripts/generate-manifest.js",
+    "build": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:better-sqlite3 && cp src/router-mcp.js dist/router-mcp.js && cp src/packages-manifest.json dist/packages-manifest.json",
+    "postinstall": "node scripts/postinstall.js",
+    "prepublishOnly": "npm run build",
+    "test": "node --test src/__tests__/"
+  },
   "dependencies": {
-    "better-sqlite3": "^12.5.0",
-    "@learnrudi/core": "1.0.5",
-    "@learnrudi/db": "1.0.2",
-    "@learnrudi/env": "1.0.1",
-    "@learnrudi/embeddings": "0.1.0",
-    "@learnrudi/manifest": "1.0.0",
-    "@learnrudi/mcp": "1.0.0",
-    "@learnrudi/registry-client": "1.0.5",
-    "@learnrudi/runner": "1.0.1",
-    "@learnrudi/utils": "1.0.0",
-    "@learnrudi/secrets": "1.0.1"
+    "@learnrudi/core": "workspace:*",
+    "@learnrudi/db": "workspace:*",
+    "@learnrudi/embeddings": "workspace:*",
+    "@learnrudi/env": "workspace:*",
+    "@learnrudi/manifest": "workspace:*",
+    "@learnrudi/mcp": "workspace:*",
+    "@learnrudi/registry-client": "workspace:*",
+    "@learnrudi/runner": "workspace:*",
+    "@learnrudi/secrets": "workspace:*",
+    "@learnrudi/utils": "workspace:*",
+    "better-sqlite3": "^12.5.0"
   },
   "devDependencies": {
     "esbuild": "^0.27.2"
@@ -49,12 +57,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
-  "scripts": {
-    "start": "node src/index.js",
-    "prebuild": "node scripts/generate-manifest.js",
-    "build": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:better-sqlite3 && cp src/router-mcp.js dist/router-mcp.js && cp src/packages-manifest.json dist/packages-manifest.json",
-    "postinstall": "node scripts/postinstall.js",
-    "test": "node --test src/__tests__/"
-  }
-}
+  "license": "MIT"
+}