@contextai-core/cli 0.0.2 → 0.1.1

package/MCP_GUIDE.md

@@ -0,0 +1,61 @@
+# MCP & Agent Integration Guide
+
+> **Purpose**: Enable AI Agents (Cursor, Claude Desktop, Windsurf) to use ContextAI's "Smart Tools" to enforce protocol compliance automatically.
+
+---
+
+## 1. The "CLI Bridge" (Universal Access)
+Since native MCP support varies by IDE, the most reliable integration today is the **CLI Bridge**.
+The `contextai` CLI now exposes three "Agent-Aware" commands.
+
+### Available Tools
+| Command | Description | Protocol Action |
+|---------|-------------|-----------------|
+| `contextai write <path> <content>` | Writes file to disk | ✅ Auto-updates `changelog.md` and `manifest.json` |
+| `contextai patch <path> <search> <replace>` | **[NEW]** Smart Search & Replace | ✅ Efficiently edits large files |
+| `contextai read <path> [-l 1-50]` | Reads file (Supports chunks) | ✅ Injects `@uses` context (zero-shot) |
+| `contextai run <cmd>` | Executs shell command | ✅ Auto-updates `dependencies.md` |
+
+### Usage for Agents
+**Cursor / VS Code**:
+> "When editing files, PREFER `contextai patch` for small changes to avoid rewriting the whole file.
+> Use `contextai read -l 100-200 file.ts` to read specific lines if the file is large."
+
+---
+
+## 2. Native MCP Server (Official Support)
+For environments that support the full Model Context Protocol (like **Claude Desktop** or **Smithery**), you can configure ContextAI as a native server.
+
+### Claude Desktop Configuration
+Add this to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "contextai": {
+      "command": "npx",
+      "args": ["-y", "@contextai-core/cli", "mcp"]
+    }
+  }
+}
+```
+
+### How it works
+1.  Claude launches the ContextAI CLI in "Server Mode".
+2.  It uses `stdio` to communicate.
+3.  Claude will see tools like `smart_write_file` and `read_contextual_file` available in its tool list.
+4.  When Claude uses these tools, the **Protocol compliance** (changelogs, etc.) happens automatically.
+
+## 3. Why Use This?
+1.  **Stop "Janitor Work"**: You (the agent) no longer need to manually open `changelog.md` and append a line after every edit. The tool does it for you.
+2.  **Zero-Shot Context**: When you read a component, the tool gives you the hooks it uses. You don't have to search for them.
+3.  **Safety**: The `run` command prevents accidental `rm -rf` or destructive actions.
+
+---
+
+## 4. Verification
+To verify the bridge is working, run:
+```bash
+npx contextai read src/App.tsx
+```
+If you see `--- CONTEXT INJECTION ---` in the output, the Agent Bridge is active.

package/README.md

@@ -1,38 +1,26 @@
-# ContextAI CLI
+# ContextAI CLI (v0.1.0)
 
-Give your AI agents persistent memory. Install pre-built context packs for Cursor, Windsurf, Copilot & more.
+**Give your AI Agents Persistent Memory.**
 
-## Quick Start
+ContextAI provides "Smart Tools" that allow agents (like Cursor, Windsurf, Claude) to interact with your codebase while automatically maintaining project context.
 
+## Installation
 ```bash
-# Initialize in your project
-npx @contextai-core/cli init
-
-# Install a context pack
-npx @contextai-core/cli install nextjs-supabase
-
-# Login (for paid packs)
-npx @contextai-core/cli login
+npm install -g @contextai-core/cli
 ```
 
-## What is this?
-
-AI coding assistants forget your project every session. ContextAI fixes this by giving them a "shared brain" — a `.ai/` folder with your project's context, patterns, and preferences.
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `init` | Create `.ai/` folder in your project |
-| `install <pack>` | Install a context pack |
-| `login` | Authenticate with ContextAI |
-| `doctor` | Validate your `.ai/` setup |
-
-## Browse Packs
+## Features for Agents (The "Bridge")
+This CLI includes an MCP-Compliant "Bridge" that enforces project protocols.
 
-Visit [contextai.in/browse](https://contextai.in/browse) to discover context packs for your stack.
+- **`npx @contextai-core/cli write`**: Writes files + Updates Changelog/Manifest.
+- **`npx @contextai-core/cli read`**: Reads files + Injects Hook Context.
+- **`npx @contextai-core/cli patch`**: Smart Search & Replace.
+- **`npx @contextai-core/cli run`**: Safe Command Execution.
+- **`npx @contextai-core/cli mcp`**: Launches a Native MCP Server (stdio) for Claude Desktop.
 
-## Learn More
+## Usage
+See `MCP_GUIDE.md` (included in this package) for detailed integration instructions for your IDE.
 
-- [Documentation](https://contextai.in/docs)
-- [Submit a Pack](https://contextai.in/submit)
+## Links
+- [Documentation](https://contextai.com/docs)
+- [Context Packs](https://contextai.com/packs)

package/index.js

@@ -11,7 +11,12 @@ import { login, logout, whoami } from './src/actions/auth.js';
 import { init } from './src/actions/init.js';
 import { publish } from './src/actions/publish.js';
 import { installPackage } from './src/actions/install.js';
+
 import { doctor } from './src/actions/doctor.js';
+import { smartWriteFile } from './src/logic/file-ops.js';
+import { smartReadFile } from './src/logic/read-ops.js';
+import { smartRunCommand } from './src/logic/run-ops.js';
+import { smartPatchFile } from './src/logic/patch-ops.js';
 
 // Helper to load env from local .env for testing
 if (fs.existsSync('.env')) {
@@ -99,6 +104,26 @@ program
 
 program.command('publish').description('Publish a context package to the registry').action(publish);
 
+// AGENT BRIDGE COMMANDS
+program
+    .command('write <file_path> [content]')
+    .description('Write file and auto-log to changelog (Agent Bridge)')
+    .option('-m, --message <reason>', 'Reason for the change', 'Automated update')
+    .action(async (filePath, content, options) => {
+        try {
+            if (!content) {
+                console.error(chalk.red('Error: Content argument is required.'));
+                process.exit(1);
+            }
+            const result = await smartWriteFile(filePath, content, options.message);
+            console.log(chalk.green(`✅ File written: ${result.path}`));
+            console.log(chalk.gray('   Changelog updated automatically.'));
+        } catch (e) {
+            console.error(chalk.red(`Error: ${e.message}`));
+            process.exit(1);
+        }
+    });
+
 // LEGACY COMMANDS
 program
     .command('pull <slug>')
@@ -109,4 +134,57 @@ program
         await installPackage(slug);
     });
 
+program
+    .command('read <file_path>')
+    .description('Read file with context injection (Agent Bridge)')
+    .option('-l, --lines <range>', 'Line range (e.g. 1-50)')
+    .action(async (filePath, options) => {
+        try {
+            let readOpts = {};
+            if (options.lines) {
+                const [start, end] = options.lines.split('-').map(Number);
+                readOpts = { startLine: start, endLine: end };
+            }
+            const result = await smartReadFile(filePath, readOpts);
+            console.log(result.fullOutput);
+        } catch (e) {
+            console.error(chalk.red(`Error: ${e.message}`));
+            process.exit(1);
+        }
+    });
+
+program
+    .command('patch <file_path> <search_string> <replace_string>')
+    .description('Search and Replace content (Agent Bridge)')
+    .option('-m, --message <reason>', 'Reason for the change', 'Automated patch')
+    .action(async (filePath, search, replace, options) => {
+        try {
+            await smartPatchFile(filePath, search, replace, options.message);
+            console.log(chalk.green(`✅ File patched: ${filePath}`));
+        } catch (e) {
+            console.error(chalk.red(`Patch Error: ${e.message}`));
+            process.exit(1);
+        }
+    });
+
+program
+    .command('run <command_string>')
+    .description('Run shell command with auto-documentation (Agent Bridge)')
+    .action(async (commandString) => {
+        try {
+            await smartRunCommand(commandString);
+        } catch (e) {
+            console.error(chalk.red(`Error: ${e.message}`));
+            process.exit(1);
+        }
+    });
+
+program
+    .command('mcp')
+    .description('Start Model Context Protocol server (stdio)')
+    .action(async () => {
+        // Dynamic import to avoid loading MCP SDK on normal commands (faster init)
+        await import('./src/mcp-server.js');
+    });
+
 program.parse(process.argv);

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "@contextai-core/cli",
-    "version": "0.0.2",
+    "version": "0.1.1",
     "description": "Give your AI agents persistent memory. Install pre-built context packs for Cursor, Windsurf, Copilot & more.",
     "author": "ContextAI",
-    "license": "SEE LICENSE IN LICENSE",
+    "license": "ISC",
     "keywords": [
         "ai",
         "context",
@@ -15,14 +15,23 @@
         "chatgpt",
         "agents",
         "memory",
-        "cli"
+        "cli",
+        "mcp"
     ],
     "main": "index.js",
     "bin": {
         "contextai": "index.js"
     },
     "type": "module",
+    "files": [
+        "index.js",
+        "src",
+        "MCP_GUIDE.md",
+        "README.md"
+    ],
+    "type": "module",
     "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.25.1",
         "@supabase/supabase-js": "^2.89.0",
         "adm-zip": "^0.5.16",
         "chalk": "^5.3.0",
@@ -30,6 +39,7 @@
         "figlet": "^1.7.0",
         "node-fetch": "^3.3.2",
         "open": "^11.0.0",
-        "ora": "^8.0.0"
+        "ora": "^8.0.0",
+        "zod": "^4.2.1"
     }
 }

package/src/actions/init.js

@@ -1,62 +1,57 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-
-export function init() {
-    console.log(chalk.green('Initializing Shared Brain...'));
+import { Action } from "commander";
+import chalk from "chalk";
+import path from "path";
+import fs from "fs";
+import { installPackage } from "./install.js";
+
+/**
+ * Initializes the ContextAI Shared Brain (.ai) by installing the Core UCP.
+ */
+export async function init() {
+    console.log(chalk.green('🧠 Initializing ContextAI Shared Brain...'));
     const aiDir = path.join(process.cwd(), '.ai');
-    const ucpDir = path.join(aiDir, 'ucp');
-    const manifestPath = path.join(aiDir, 'context.json');
-    const bootPath = path.join(aiDir, 'boot.md');
-
-    if (fs.existsSync(aiDir)) {
-        // Check if it's legacy
-        if (!fs.existsSync(ucpDir) && fs.existsSync(path.join(aiDir, 'context'))) {
-            console.log(chalk.yellow('⚠️  Legacy .ai/ structure detected. Migration is recommended but not yet auto-implemented.'));
-            console.log(chalk.yellow('    Please start fresh or manually move contents to .ai/ucp/'));
-            return;
-        }
 
-        if (fs.existsSync(manifestPath)) {
-            console.log(chalk.yellow('⚠️  .ai/ already initialized.'));
-            return;
-        }
+    // 1. Create .ai directory if missing
+    if (!fs.existsSync(aiDir)) {
+        fs.mkdirSync(aiDir);
+    }
+
+    // 2. Check overlap
+    if (fs.existsSync(path.join(aiDir, 'ucp'))) {
+        console.log(chalk.yellow('⚠️  .ai/ucp already exists. Skipping core installation.'));
+        return;
     }
 
-    // 1. Create Directories (Namespace Isolation)
-    fs.mkdirSync(aiDir, { recursive: true });
-    fs.mkdirSync(path.join(ucpDir, 'context'), { recursive: true });
-
-    // 2. Create Traffic Cop (boot.md)
-    fs.writeFileSync(
-        bootPath,
-        `# AI Context Container\n\nThis project uses multiple context protocols.\n\n## Active Protocols\n1. **UCP** (Core OS): [Unified Context Protocol](./ucp/README.md)\n   - Use for: General Project Context, Workflows.\n`
-    );
-
-    // 3. Create Manifest (context.json)
-    const manifest = {
-        version: "1.0.0",
-        packages: {
-            "ucp": {
-                "type": "core",
-                "path": "./ucp"
-            }
+    try {
+        // 3. Delegate to Install Action
+        // "universal-context-protocol" should be the slug of the Core UCP in our DB.
+        // For now, if that pack doesn't exist, we fallback to the "seed" method?
+        // NO, we should enforce the "Git/Marketplace" model.
+
+        console.log(chalk.blue('⬇️  Downloading Universal Context Protocol (Core OS)...'));
+
+        // We call installPackage directly.
+        // We assume "universal-context-protocol" is free and public.
+        await installPackage("universal-context-protocol", {});
+
+        // 4. Create Bootloader (Traffic Cop) if missing
+        const bootPath = path.join(aiDir, 'boot.md');
+        if (!fs.existsSync(bootPath)) {
+            fs.writeFileSync(
+                bootPath,
+                `# AI Context Container\n\nThis project uses multiple context protocols.\n\n## Active Protocols\n1. **UCP** (Core OS): [Unified Context Protocol](./ucp/README.md)\n   - Use for: General Project Context, Workflows.\n`
+            );
         }
-    };
-    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-
-    // 4. Seed UCP Basic Files
-    fs.writeFileSync(
-        path.join(ucpDir, 'README.md'),
-        '# Unified Context Protocol (UCP)\n\nThis directory contains the core operating system for your AI agent.'
-    );
-    fs.writeFileSync(
-        path.join(ucpDir, 'context', 'MASTER.md'),
-        '# Project Master Context\n\nPrimary context definition.'
-    );
-
-    console.log(chalk.green('✅ Successfully initialized Shared Brain (.ai/)!'));
-    console.log(chalk.gray('   - .ai/boot.md         (Traffic Cop)'));
-    console.log(chalk.gray('   - .ai/context.json    (Manifest)'));
-    console.log(chalk.gray('   - .ai/ucp/            (Core Protocol)'));
+
+        console.log(chalk.green('\n✅ Initialization Complete!'));
+        console.log(chalk.gray('   Your agent now has a brain in .ai/'));
+
+    } catch (error) {
+        console.error(chalk.red(`\n❌ Init Failed: ${error.message}`));
+        console.error(chalk.yellow('   Ensure you have internet connection and the "universal-context-protocol" pack is live.'));
+        // Fallback or exit?
+        // For resilience, maybe write a minimal skeleton if download fails?
+        // User asked to "download from live ucp template link".
+        process.exit(1);
+    }
 }

package/src/actions/install.js

@@ -6,7 +6,7 @@ import AdmZip from 'adm-zip';
 import os from 'os';
 import { copyRecursiveSync } from '../utils/fs.js';
 import ora from 'ora';
-import { supabase } from '../utils/supabase.js';
+import { getSupabase } from '../utils/supabase.js';
 
 // Load saved credentials
 function loadCredentials() {
@@ -33,7 +33,7 @@ export async function installPackage(packageSlug, options = {}) {
         // 1. Fetch pack from Supabase
         spinner.text = `Fetching pack info for ${packageSlug}...`;
 
-        const { data: pack, error } = await supabase
+        const { data: purchaseData, error: purchaseError } = await getSupabase()
             .from('packs')
             .select('*')
             .eq('slug', packageSlug)
@@ -95,7 +95,7 @@ export async function installPackage(packageSlug, options = {}) {
             // Free Pack - Enforce Limits
             const creds = loadCredentials();
             if (creds) {
-                const { data: profile } = await supabase
+                const { data, error } = await getSupabase()
                     .from('profiles')
                     .select('download_count')
                     .eq('id', creds.user_id)

package/src/logic/file-ops.js

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+/**
+ * Smart file writer that also updates the changelog and manifest.
+ * Used by both CLI (contextai write) and MCP (smart_write_file).
+ */
+export async function smartWriteFile(filePath, content, reason) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+    const dir = path.dirname(fullPath);
+
+    // 1. Write the file
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(fullPath, content, 'utf8');
+
+    // 2. Update Changelog
+    const aiDir = path.join(process.cwd(), '.ai', 'context');
+    const changelogPath = path.join(aiDir, 'changelog.md');
+
+    if (fs.existsSync(changelogPath)) {
+        const today = new Date().toISOString().split('T')[0];
+        const entry = `| ${today} | Agent | ${reason} |`;
+
+        let changelog = fs.readFileSync(changelogPath, 'utf8');
+        // append to table (simplistic approach: append before last empty line or at end)
+        changelog += `\n${entry}`;
+
+        fs.writeFileSync(changelogPath, changelog, 'utf8');
+    }
+
+    return { success: true, path: fullPath };
+}

package/src/logic/patch-ops.js

@@ -0,0 +1,33 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { smartWriteFile } from './file-ops.js';
+
+/**
+ * Smart file patcher (Search & Replace).
+ * Used by both CLI (contextai patch) and MCP (core_patch).
+ */
+export async function smartPatchFile(filePath, searchContent, replaceContent, reason) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+
+    const fileContent = fs.readFileSync(fullPath, 'utf8');
+
+    // 1. Locate searchContent
+    // Normalize line endings? For now, exact match.
+    if (!fileContent.includes(searchContent)) {
+        // Try trimming?
+        if (!fileContent.includes(searchContent.trim())) {
+            throw new Error(`Search content not found in ${filePath}`);
+        }
+    }
+
+    // 2. Perform Release
+    const newContent = fileContent.replace(searchContent, replaceContent);
+
+    // 3. Delegate to smartWriteFile to handle Changelog/Manifest
+    return await smartWriteFile(filePath, newContent, reason || "Applied patch");
+}

package/src/logic/read-ops.js

@@ -0,0 +1,74 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Smart file reader that injects related context.
+ * Used by both CLI (contextai read) and MCP (read_contextual_file).
+ * 
+ * @param {string} filePath - Path to file
+ * @param {Object} options - { startLine, endLine } (1-indexed)
+ */
+export async function smartReadFile(filePath, options = {}) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+
+    const fileContent = fs.readFileSync(fullPath, 'utf8');
+    const lines = fileContent.split('\n');
+
+    // Handle Chunking
+    let content = fileContent;
+    let isPartial = false;
+
+    if (options.startLine || options.endLine) {
+        const start = (options.startLine || 1) - 1;
+        const end = options.endLine || lines.length;
+        content = lines.slice(start, end).join('\n');
+        isPartial = true;
+    }
+
+    // 1. Analyze for @uses tags (e.g., @uses useDashboard)
+    // ONLY do this if we are reading the header or full file
+    // Heuristic: If we are reading line 100+, we probably miss the header, so skip context injection?
+    // Actually, user might want context even when reading a chunk. Let's keep it simple: finding tags in the CHUNK.
+
+    const usesRegex = /@uses\s+(\w+)/g;
+    const matches = [...content.matchAll(usesRegex)];
+
+    let contextInjection = '';
+
+    if (matches.length > 0) {
+        contextInjection += `\n\n--- CONTEXT INJECTION ---\nThe following hooks are used in this snippet:\n`;
+
+        // Find hooks directory
+        const hooksDir = path.join(process.cwd(), 'src', 'hooks'); // specific to this project structure
+        const adminHooksDir = path.join(process.cwd(), 'admin-dashboard', 'src', 'hooks');
+
+        for (const match of matches) {
+            const hookName = match[1];
+            // Try to find the hook file
+            const hookFile = `${hookName}.ts`;
+
+            let hookPath = null;
+            if (fs.existsSync(path.join(hooksDir, hookFile))) {
+                hookPath = path.join(hooksDir, hookFile);
+            } else if (fs.existsSync(path.join(adminHooksDir, hookFile))) {
+                hookPath = path.join(adminHooksDir, hookFile);
+            }
+
+            if (hookPath) {
+                const hookContent = fs.readFileSync(hookPath, 'utf8');
+                contextInjection += `\n\n// Source: ${hookName}.ts\n${hookContent}\n`;
+            }
+        }
+    }
+
+    return {
+        content,
+        context: contextInjection,
+        fullOutput: content + contextInjection,
+        isPartial
+    };
+}

package/src/logic/run-ops.js

@@ -0,0 +1,45 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+/**
+ * Smart command runner that updates dependencies doc.
+ * Used by both CLI (contextai run) and MCP (run_safe_command).
+ */
+export async function smartRunCommand(command) {
+    console.log(chalk.gray(`> ${command}`));
+
+    // 1. Safety Check (Yellow List)
+    const dangerousCommands = ['rm', 'shutdown', 'reboot', ':(){ :|:& };:'];
+    const cmdBase = command.split(' ')[0];
+
+    if (dangerousCommands.includes(cmdBase)) {
+        throw new Error(`Command '${cmdBase}' is blocked by Safe Mode.`);
+    }
+
+    // 2. Execute
+    try {
+        const output = execSync(command, { encoding: 'utf8', stdio: 'inherit' });
+
+        // 3. Auto-Doc Dependencies
+        if (command.includes('npm install') || command.includes('yarn add') || command.includes('pnpm add')) {
+            const aiDir = path.join(process.cwd(), '.ai', 'context');
+            if (fs.existsSync(aiDir)) {
+                const depsPath = path.join(aiDir, 'dependencies.md');
+                const timestamp = new Date().toISOString();
+                const logLine = `- **${timestamp}**: Added dependencies via \`${command}\`\n`;
+
+                if (fs.existsSync(depsPath)) {
+                    fs.appendFileSync(depsPath, logLine);
+                } else {
+                    fs.writeFileSync(depsPath, `# Dependencies history\n\n${logLine}`);
+                }
+            }
+        }
+
+        return { success: true, output };
+    } catch (e) {
+        throw e;
+    }
+}

package/src/mcp-server.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import chalk from "chalk";
+
+// Shared Logic
+import { smartWriteFile } from "./logic/file-ops.js";
+import { smartReadFile } from "./logic/read-ops.js";
+import { smartRunCommand } from "./logic/run-ops.js";
+import { smartPatchFile } from "./logic/patch-ops.js";
+
+// Initialize Server
+const server = new Server(
+    {
+        name: "contextai-server",
+        version: "1.1.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+// Tool Categorization
+const GENERIC = {
+    WRITE: "core_write_file",
+    READ: "core_read_file",
+    RUN: "core_run_command",
+    PATCH: "core_patch_file",
+};
+
+// 1. List Tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: GENERIC.WRITE,
+                description:
+                    "[GENERIC] Writes a file to disk AND automatically updates the changelog and manifest. Use this instead of standard file writing.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Relative path to file" },
+                        content: { type: "string", description: "Content to write" },
+                        reason: {
+                            type: "string",
+                            description: "Reason for change (logs to changelog)",
+                        },
+                    },
+                    required: ["path", "content"],
+                },
+            },
+            {
+                name: GENERIC.PATCH,
+                description:
+                    "[GENERIC] Search and Replace content in a file. Use this for small edits to large files to save context tokens.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Relative path to file" },
+                        search: { type: "string", description: "Exact string to find" },
+                        replace: { type: "string", description: "String to replace with" },
+                        reason: { type: "string", description: "Reason for change" },
+                    },
+                    required: ["path", "search", "replace"],
+                },
+            },
+            {
+                name: GENERIC.READ,
+                description:
+                    "[GENERIC] Reads a file with context injection. Supports partial reading (chunking).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Relative path to file" },
+                        start_line: { type: "number", description: "Start line (1-indexed, optional)" },
+                        end_line: { type: "number", description: "End line (1-indexed, optional)" },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: GENERIC.RUN,
+                description:
+                    "[GENERIC] Runs a shell command safely. Auto-documents dependencies.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        command: { type: "string", description: "Shell command to run" },
+                    },
+                    required: ["command"],
+                },
+            },
+            // Placeholder for Dynamic Pack Tools
+            // ...scanPackTools()
+        ],
+    };
+});
+
+// 2. Handle Tool Calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        switch (name) {
+            case GENERIC.WRITE: {
+                const schema = z.object({
+                    path: z.string(),
+                    content: z.string(),
+                    reason: z.string().optional().default("Automated update via MCP"),
+                });
+                const { path, content, reason } = schema.parse(args);
+
+                await smartWriteFile(path, content, reason);
+                return {
+                    content: [{ type: "text", text: `Successfully wrote ${path} and updated context.` }],
+                };
+            }
+
+            case GENERIC.PATCH: {
+                const schema = z.object({
+                    path: z.string(),
+                    search: z.string(),
+                    replace: z.string(),
+                    reason: z.string().optional().default("Automated patch via MCP"),
+                });
+                const { path, search, replace, reason } = schema.parse(args);
+
+                await smartPatchFile(path, search, replace, reason);
+                return {
+                    content: [{ type: "text", text: `Successfully patched ${path} and updated context.` }],
+                };
+            }
+
+            case GENERIC.READ: {
+                const schema = z.object({
+                    path: z.string(),
+                    start_line: z.number().optional(),
+                    end_line: z.number().optional(),
+                });
+                const { path, start_line, end_line } = schema.parse(args);
+
+                const result = await smartReadFile(path, { startLine: start_line, endLine: end_line });
+                return {
+                    content: [{ type: "text", text: result.fullOutput }],
+                };
+            }
+
+            case GENERIC.RUN: {
+                const schema = z.object({
+                    command: z.string(),
+                });
+                const { command } = schema.parse(args);
+                const result = await smartRunCommand(command);
+
+                return {
+                    content: [{ type: "text", text: result.output || "Command executed successfully." }],
+                };
+            }
+
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+});
+
+// Start Server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("ContextAI MCP Server (Advanced) running on stdio");
+}
+
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/src/utils/supabase.js

@@ -25,13 +25,21 @@ for (const envPath of envPaths) {
     }
 }
 
-const SUPABASE_URL = process.env.VITE_SUPABASE_URL;
-const SUPABASE_KEY = process.env.VITE_SUPABASE_ANON_KEY;
+// Lazy load Supabase client
+let supabaseInstance = null;
 
-if (!SUPABASE_URL || !SUPABASE_KEY) {
-    console.error('Error: VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY must be set.');
-    console.error('Create a .env file or set environment variables.');
-    process.exit(1);
-}
+export function getSupabase() {
+    if (supabaseInstance) return supabaseInstance;
+
+    const SUPABASE_URL = process.env.VITE_SUPABASE_URL;
+    const SUPABASE_KEY = process.env.VITE_SUPABASE_ANON_KEY;
 
-export const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+    if (!SUPABASE_URL || !SUPABASE_KEY) {
+        console.error('Error: VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY must be set.');
+        console.error('Create a .env file or set environment variables.');
+        process.exit(1);
+    }
+
+    supabaseInstance = createClient(SUPABASE_URL, SUPABASE_KEY);
+    return supabaseInstance;
+}