@kawacode/mcp 5.0.0

package/CLAUDE.md.example

@@ -0,0 +1,80 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+<!-- Replace with a 1-2 sentence description of your project -->
+[Your project name] is a [brief description of what it does].
+
+## AI Code Implementation Workflow
+
+**BEFORE exploring code or reading files** for any non-trivial task, follow these steps in order:
+
+1. **Check active intent**: Call `check_active_intent` (kawa-intents MCP) to see if work is already tracked
+2. **Get relevant context**: Call `get_relevant_context` with a description of the task to find past decisions and related intents that may inform your approach
+3. **Then explore code**: Now read files, search the codebase, and analyze the problem
+
+For trivial one-line fixes (typos, obvious bugs), skip the above and use `log_work` after completing the change. For everything else — especially bug fixes from issues, multi-file changes, or unfamiliar code — always start with steps 1-2.
+
+**Recording decisions before commit**: When the user asks to finalize/commit, review the work done in the session and call `record_decision` for each significant decision or lesson *before* creating the commit. Apply a **high bar**: a decision is worth recording only if a future developer (or Claude in a future session) would genuinely benefit from knowing it — i.e., it would change how they approach the same area of code.
+
+Record when you:
+- Chose between meaningful alternatives (type: `fork`) — e.g., serde alias vs fixing all reconstruction sites
+- Discovered non-obvious behavior that will recur or affect future work (type: `discovery`) — e.g., UI progress tracking requires completion events per phase
+- Identified a hard constraint that future work must respect (type: `constraint`) — e.g., checkpoint cleanup must wait for persistence
+- Made an explicit trade-off with lasting impact (type: `tradeoff`) — e.g., precision vs simplicity in rate limiting
+- Tried and rejected an approach that looked reasonable (type: `abandoned`)
+- Selected a library or dependency after comparing alternatives (type: `dependency`) — e.g., chose `reqwest` over `hyper` for HTTP
+
+Do NOT record:
+- Routine refactors, obvious bug fixes, version bumps, formatting changes
+- Session-only debugging artifacts (e.g., a stray `test.only` or `console.log` that was removed)
+- Anything where the "lesson" is obvious in hindsight or already clear from the code/diff
+- Gotchas with no future recurrence risk (one-off typos, copy-paste errors, trivial config mistakes)
+- Decisions with no meaningful alternatives considered
+
+**Committing pre-existing changes**: When uncommitted changes exist that weren't made under an active intent, infer intents retroactively: read the diffs, group changes by semantic purpose, call `list_team_intents` to find existing intents that accurately match each group, then commit each group under its matched intent (create a new intent if no accurate match found). Present the grouping plan to the user before committing. Use `log_work` for trivial standalone changes.
+
+## Repository Origin and Path
+
+Use these values for ALL MCP tool calls:
+
+<!-- Replace with your actual values -->
+- `repoOrigin`: `git@github.com:your-org/your-repo.git`
+- `repoPath`: `/absolute/path/to/your-repo`
+
+**Important**: `repoPath` must point to the directory containing the `.git` folder.
+
+<!-- ============================================================
+     EVERYTHING BELOW IS OPTIONAL — add what's useful for your project
+     ============================================================ -->
+
+<!-- OPTIONAL: For monorepos or multi-project workspaces, replace the
+     single repoOrigin/repoPath above with a table:
+
+### Repository Origins and Paths
+
+Each sub-project has its own `.git` directory. When calling MCP tools, use the **sub-project path** (not the parent directory) as `repoPath`:
+
+| Sub-project | `repoOrigin`                            | `repoPath`                       |
+|-------------|-----------------------------------------|----------------------------------|
+| my-api      | `git@github.com:my-org/my-api.git`      | `/path/to/workspace/my-api`      |
+| my-frontend | `git@github.com:my-org/my-frontend.git` | `/path/to/workspace/my-frontend` |
+-->
+
+<!-- OPTIONAL: Add project-specific sections as needed.
+     Examples of what to include:
+
+## Development Commands
+- How to run tests, lint, build, etc.
+
+## Code Style
+- Project conventions Claude should follow
+
+## Architecture
+- Key architectural decisions or patterns
+
+## Important Files
+- Files Claude should know about
+-->

package/LICENSE

@@ -0,0 +1,35 @@
+Code Awareness Source Available License (CASAL) v1.0
+
+Copyright (c) 2026 Code Awareness LLC
+
+Permission is granted to use, copy, modify, and run this
+software for personal use, research, or internal organizational
+use when interacting with Code Awareness tools.
+
+You may:
+
+• Run the software locally
+• Modify the software for internal purposes
+• Study the source code
+• Submit contributions
+
+You may NOT:
+
+• Use this software to build or operate a competing
+AI memory, intent-tracking, or development governance system.
+
+• Offer this software or derivatives as a hosted service.
+
+• Redistribute this software as part of a commercial product
+without written permission from Code Awareness LLC.
+
+PATENT RIGHTS
+
+This license does not grant rights to any patents owned by
+Code Awareness LLC except as necessary to use the software
+under this license.
+
+DISCLAIMER
+
+The software is provided "as is", without warranty of any kind.
+

package/README.md

@@ -0,0 +1,322 @@
+# kawa.mcp
+
+Reference implementation of the Kawa Code MCP protocol.
+
+## Overview
+
+The Kawa Code MCP server provides the communication layer used by
+Kawa Code to record and align development intent between
+developers and AI systems.
+
+It enables:
+
+• Persistent AI reasoning context
+• Intent tracking during development workflows
+• Alignment between human and AI decisions over time
+
+This repository contains the reference implementation of the
+Kawa MCP server used by Kawa Code tools.
+
+This MCP server enables AI coding assistants to understand what you're working on and maintain context across sessions. It connects to the Kawa Code desktop application to provide:
+
+- **Intent tracking**: Create and manage development intents with decision history
+- **Team collaboration**: See what teammates are working on, detect conflicts
+- **Decision recording**: Track architectural decisions and trade-offs with constraint validation
+- **Code block assignment**: Associate code changes with intents for better commit history
+
+## Usage
+
+The MCP server works together with Kawa Code, AI code generators such as Cursor, Claude Code,
+and the Kawa Code extensions.
+
+## Key Features
+
+- **Context Persistence**: Never lose track of what you were working on across AI sessions
+- **Smart Context Retrieval**: Relevance-based context loading - only fetch what's needed for the current task
+- **Zero-Knowledge Encryption**: Code blocks encrypted client-side before cloud sync, API cannot decrypt
+- **Team Conflict Detection**: Know when teammates are working on the same files/lines
+- **Decision Tracking**: Record architectural decisions with constraint validation and conflict detection
+- **Commit Integration**: Link all code changes to intent context for better git history
+- **Cross-Platform**: Works with Claude Code and Cursor AI via MCP protocol
+
+## Prerequisites
+
+### Required
+
+- **Node.js >= 18.0.0** — runtime for the MCP server
+- **[Kawa Code](https://codeawareness.com/product) desktop app running** — kawa.mcp is a thin MCP-to-IPC adapter; all git operations, storage, and API communication happen in Kawa Code
+- **Active Kawa Code account** — for cloud sync and team features
+
+### Optional (for history inference)
+
+- **Anthropic API key** — your own Claude API key, passed as a parameter to the inference tools
+- **[GitHub CLI (`gh`)](https://cli.github.com/)** — enables richer data tiers (PR descriptions, review comments, issue discussions). Without `gh`, tiers 2 and 4 are skipped automatically
+
+## Installation
+
+```bash
+# Clone the repository (if not already cloned)
+cd /path/to/kawa.mcp
+
+# Install dependencies
+npm install
+
+# Build the TypeScript source
+npm run build
+```
+
+## Quick Start
+
+1. **Start Kawa Code**: Launch the Kawa Code desktop app and log in
+2. **Configure MCP**: Add kawa.mcp to your AI assistant's MCP configuration (see Configuration section)
+3. **Restart AI**: Restart Claude Code or Cursor to load the MCP server
+4. **Test connection**: The server will try to connect to Kawa Code on startup
+5. **Start coding**: Use `check_active_intent` to begin tracking your work
+
+## Setting Up CLAUDE.md
+
+For Claude Code to use the MCP tools effectively, your project needs a `CLAUDE.md` file that tells Claude *when* to call the tools and provides your repository coordinates.
+
+Copy the example template into your project root and fill in the placeholders:
+
+```bash
+cp /path/to/kawa.mcp/CLAUDE.md.example /path/to/your-project/CLAUDE.md
+```
+
+Or just merge the example with your own content.
+See [`CLAUDE.md.example`](./CLAUDE.md.example) for the full template with optional sections for monorepos, code style, and architecture.
+
+## Configuration
+
+### Claude Code
+
+Create a `.mcp.json` file in your project root (recommended for teams — commit it to git):
+
+```json
+{
+  "mcpServers": {
+    "kawa-intents": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["/absolute/path/to/kawa.mcp/build/index.js"]
+    }
+  }
+}
+```
+
+Or add it at user level (available across all your projects):
+
+```bash
+claude mcp add --transport stdio kawa-intents --scope user -- node /absolute/path/to/kawa.mcp/build/index.js
+```
+
+### Cursor AI
+
+Add to your Cursor MCP configuration (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "kawa-intents": {
+      "command": "node",
+      "args": ["/absolute/path/to/kawa.mcp/build/index.js"]
+    }
+  }
+}
+```
+
+**Important:** Use absolute paths, not relative paths or `~` shortcuts.
+
+## Available Tools
+
+### Context & Discovery
+
+| Tool                   | Description                             |
+|------------------------|-----------------------------------------|
+| `get_relevant_context` | Get context relevant to a specific task |
+
+### Intent Management
+
+| Tool                         | Description                                                |
+|------------------------------|------------------------------------------------------------|
+| `check_active_intent`        | Check if there's an active intent before starting new work |
+| `create_and_activate_intent` | Create and activate a new intent for a development task    |
+| `get_intents_for_file`       | Get intents (team and self) affecting a specific file      |
+| `get_intents_for_lines`      | Get intents affecting specific line ranges in a file       |
+| `assign_blocks_to_intent`    | Assign modified line ranges to the active intent           |
+| `get_intent_changes`         | Get uncommitted changes for the active intent              |
+| `complete_intent`            | Complete an intent (committed/done/abandoned)              |
+| `list_team_intents`          | List what teammates are currently working on               |
+
+### Decision Recording
+
+| Tool                      | Description                                                               |
+|---------------------------|---------------------------------------------------------------------------|
+| `record_decision`         | Record an architectural decision with rationale and constraint validation |
+| `get_session_decisions`   | Get decisions recorded during the current session                         |
+| `get_project_decisions`   | Get all decisions across all intents for the project                      |
+| `edit_session_decision`   | Edit or delete a decision before intent completion                        |
+| `detect_intent_conflicts` | Detect if current intent decisions conflict with team decisions           |
+
+### History Inference
+
+| Tool               | Description                                                            |
+|--------------------|------------------------------------------------------------------------|
+| `infer_history`    | Analyze git commit history to extract development stories and decisions |
+| `evolve_decisions` | Build a decision evolution graph from previously extracted stories       |
+
+### Lightweight Logging
+
+| Tool       | Description                                                                                    |
+|------------|------------------------------------------------------------------------------------------------|
+| `log_work` | Log completed work without the full intent lifecycle — use for quick fixes and trivial changes |
+
+## MCP Capabilities
+
+### Prompts
+
+The server exposes prompts that can be loaded into your AI coding session:
+
+- **`implementation_workflow`**: Standard workflow for implementing code changes with intent tracking. Provides step-by-step guidance on checking for active intents, creating new intents, checking for conflicts, and assigning blocks.
+
+### Resources
+
+The server exposes resources that can be monitored:
+
+- **`kawa://intent/active`**: Real-time view of the currently active intent for the connected repository (JSON format)
+
+## History Inference
+
+Two MCP tools analyze git commit history to extract structured development knowledge — useful for bootstrapping a repository with historical context.
+
+### `infer_history`
+
+Runs the full pipeline automatically: **infer → evolve → persist**.
+
+1. **Pass 1**: Groups commits into coherent development stories with value hints (high/low/none)
+2. **Pass 2**: Deep analysis of high/low-value stories to extract architectural decisions and lessons learned
+3. **Evolution**: Curates decisions by finding relationships (supersedes, reinforces, contradicts, specializes)
+4. **Persist**: Stores curated stories as intents with decisions and lessons (auto-syncs to cloud)
+
+The pipeline runs asynchronously inside Kawa Code. Progress is shown in the Kawa Code desktop app via a progress bar. The pipeline supports checkpointing — if interrupted, re-running resumes from where it left off.
+
+**Usage in Claude Code:**
+
+```
+Use the infer_history tool with estimateOnly: true to preview the cost first,
+then run it with estimateOnly: false.
+```
+
+**Parameters:**
+
+| Parameter              | Type    | Default                    | Description                                                            |
+|------------------------|---------|----------------------------|------------------------------------------------------------------------|
+| `repoPath`             | string  | *(required)*               | Local path to the repository root                                      |
+| `apiKey`               | string  | *(required)*               | Your Anthropic API key                                                 |
+| `commits`              | number  | 50                         | Number of recent commits to analyze                                    |
+| `tier`                 | number  | 4                          | Data enrichment tier (1-5, see below)                                  |
+| `model`                | string  | claude-sonnet-4-20250514   | Anthropic model to use                                                 |
+| `maxStories`           | number  | 0                          | Limit stories to analyze in Pass 2 (0 = unlimited)                     |
+| `allowCommitSplitting` | boolean | false                      | Allow splitting a commit into multiple stories when it contains unrelated changes (recommended for repos with messy commit history) |
+| `contextIssues`        | boolean | false                      | Include context issues from commit date range (tier 4 only)            |
+| `estimateOnly`         | boolean | false                      | Preview token cost without running the pipeline                        |
+
+### `evolve_decisions`
+
+Builds a decision evolution graph from previously extracted stories — identifying how decisions relate across stories over time. Note: `infer_history` already chains evolve + persist automatically. Use this tool only if you want to run evolution separately on a pre-existing set of stories.
+
+1. **Bucketing**: Groups stories by file overlap and keyword similarity
+2. **Edge classification**: Uses LLM to identify relationships (supersedes, reinforces, contradicts, specializes)
+3. **Annotation**: Labels each decision as stable, orphan, evolved, or abandoned
+4. **Curation**: Keeps stable + orphan decisions, drops evolved + abandoned
+
+If `repoPath` is provided, curated stories are automatically persisted as intents with decisions and lessons after evolution completes.
+
+**Parameters:**
+
+| Parameter    | Type   | Default                       | Description                                                        |
+|--------------|--------|-------------------------------|--------------------------------------------------------------------|
+| `stories`    | array  | *(required)*                  | Story objects from a previous `infer_history` run                  |
+| `apiKey`     | string | *(required)*                  | Your Anthropic API key                                             |
+| `model`      | string | claude-haiku-4-5-20251001     | Anthropic model (cheaper model recommended)                        |
+| `repoPath`   | string | *(optional)*                  | Local path to repository root (required for auto-persist)          |
+| `repoOrigin` | string | *(optional)*                  | Git remote origin URL (auto-detected from repoPath if not provided)|
+
+### Data Tiers
+
+Each tier adds more context for better inference. Higher tiers require the [`gh` CLI](https://cli.github.com/) authenticated.
+
+| Tier | Data source                                        | Requires `gh` |
+|------|----------------------------------------------------|---------------|
+| 1    | Commit messages + numstat                          | No            |
+| 2    | + PR descriptions and review comments              | Yes           |
+| 3    | + Diffs for revert commits                         | No            |
+| 4    | + Referenced GitHub issues (default)               | Yes           |
+| 5    | + Diffs for all commits with annotation extraction | No            |
+
+## Development
+
+```bash
+# Watch mode (auto-rebuild on file changes)
+npm run dev
+
+# Build TypeScript to JavaScript
+npm run build
+
+# Clean build artifacts
+npm run clean
+
+# Run the MCP server directly
+npm start
+```
+
+### Testing the MCP Server
+
+To test the MCP server without integrating it into an AI assistant:
+
+1. Build the project: `npm run build`
+2. Run the server: `npm start`
+3. The server communicates via stdio (standard input/output)
+4. You can send MCP protocol messages via stdin to test tool functionality
+
+### Development Tips
+
+- Use `npm run dev` to auto-rebuild during development
+- Check stderr for server logs (stdout is reserved for MCP protocol)
+- Ensure Kawa Code is running before testing
+
+## Architecture
+
+```
+Claude Code / Cursor AI
+    ↓ MCP Protocol (stdio)
+kawa.mcp (this server)
+    ↓ Huginn IPC (Unix socket / Named pipe)
+Kawa Code Desktop App
+    ├─ Gardener Module (Rust)
+    │   └─ Intent/Decision storage
+    └─ HTTP Client
+        ↓ REST + SSE
+    Kawa API (cloud)
+        └─ Team sync & encryption
+```
+
+The MCP server communicates with Kawa Code using the Huginn IPC protocol:
+- **Context queries**: Intents, decisions, relevant context
+- **Intent operations**: Create, update, assign blocks, complete
+- **Decision tracking**: Record, retrieve, edit, conflict detection
+
+Kawa Code's Gardener module handles all git operations, diff generation, and local storage of encrypted data.
+
+## Contributing
+
+Contributions are welcome. Please read [CONTRIBUTING.md](CONTRIBUTION.md) and [CLA.md](CLA.md).
+
+## License
+
+This project is source-available under the
+Kawa Code Source Available License.
+
+You may run and modify the software for personal or internal use.
+
+See [LICENSE](LICENSE) for details.

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { connectToMuninn, ensureRepo } from './services/muninn-ipc.js';
+import { allTools, getRelevantContext, checkActiveIntent, createAndActivateIntent, getIntentsForFile, getIntentsForLines, assignBlocksToIntent, listTeamIntents, getIntentChanges, completeIntent, logWork, recordDecision, getSessionDecisions, getProjectDecisions, editSessionDecision, detectIntentConflicts, inferHistory, evolveDecisions } from './tools/index.js';
+import { prompts } from './prompts/intent-first-workflow.js';
+import { resources, readActiveIntentResource } from './resources/active-intent.js';
+// Create MCP server
+const server = new Server({
+    name: 'kawa-intents',
+    version: '0.3.0'
+}, {
+    capabilities: {
+        tools: {},
+        prompts: {},
+        resources: {}
+    }
+});
+// Handle tool listing
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: allTools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: 'object',
+                properties: Object.fromEntries(Object.entries(tool.inputSchema.shape).map(([key, value]) => [
+                    key,
+                    {
+                        ...getZodSchema(value),
+                        description: value._def?.description || ''
+                    }
+                ])),
+                required: Object.entries(tool.inputSchema.shape)
+                    .filter(([_, value]) => isRequired(value))
+                    .map(([key]) => key)
+            }
+        }))
+    };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const repoPath = args?.repoPath;
+        if (repoPath) {
+            await ensureRepo(repoPath);
+        }
+        let result;
+        switch (name) {
+            case 'get_relevant_context':
+                result = await getRelevantContext(args);
+                break;
+            case 'check_active_intent':
+                result = await checkActiveIntent(args);
+                break;
+            case 'create_and_activate_intent':
+                result = await createAndActivateIntent(args);
+                break;
+            case 'get_intents_for_file':
+                result = await getIntentsForFile(args);
+                break;
+            case 'get_intents_for_lines':
+                result = await getIntentsForLines(args);
+                break;
+            case 'assign_blocks_to_intent':
+                result = await assignBlocksToIntent(args);
+                break;
+            case 'list_team_intents':
+                result = await listTeamIntents(args);
+                break;
+            case 'get_intent_changes':
+                result = await getIntentChanges(args);
+                break;
+            case 'complete_intent':
+                result = await completeIntent(args);
+                break;
+            case 'log_work':
+                result = await logWork(args);
+                break;
+            case 'record_decision':
+                result = await recordDecision(args);
+                break;
+            case 'get_session_decisions':
+                result = await getSessionDecisions(args);
+                break;
+            case 'get_project_decisions':
+                result = await getProjectDecisions(args);
+                break;
+            case 'edit_session_decision':
+                result = await editSessionDecision(args);
+                break;
+            case 'detect_intent_conflicts':
+                result = await detectIntentConflicts(args);
+                break;
+            case 'infer_history':
+                result = await inferHistory(args);
+                break;
+            case 'evolve_decisions':
+                result = await evolveDecisions(args);
+                break;
+            default:
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }
+            ]
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Tool execution failed';
+        throw new McpError(ErrorCode.InternalError, message);
+    }
+});
+// Handle prompt listing
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return {
+        prompts: prompts.map(p => ({
+            name: p.name,
+            description: p.description,
+            arguments: p.arguments
+        }))
+    };
+});
+// Handle prompt retrieval
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const prompt = prompts.find(p => p.name === name);
+    if (!prompt) {
+        throw new McpError(ErrorCode.InvalidRequest, `Unknown prompt: ${name}`);
+    }
+    return {
+        description: prompt.description,
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: prompt.getPrompt(args)
+                }
+            }
+        ]
+    };
+});
+// Handle resource listing
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+        resources: resources.map(r => ({
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType
+        }))
+    };
+});
+// Handle resource reading
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri === 'kawa://intent/active') {
+        const content = await readActiveIntentResource();
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'application/json',
+                    text: content
+                }
+            ]
+        };
+    }
+    throw new McpError(ErrorCode.InvalidRequest, `Unknown resource: ${uri}`);
+});
+// Helper to convert Zod types to JSON Schema property objects
+function getZodSchema(zodType) {
+    const typeName = zodType._def?.typeName;
+    switch (typeName) {
+        case 'ZodString':
+            return { type: 'string' };
+        case 'ZodNumber':
+            return { type: 'number' };
+        case 'ZodBoolean':
+            return { type: 'boolean' };
+        case 'ZodArray':
+            return { type: 'array', items: getZodSchema(zodType._def.type) };
+        case 'ZodObject':
+            return { type: 'object' };
+        case 'ZodEnum':
+            return { type: 'string', enum: zodType._def.values };
+        case 'ZodOptional':
+        case 'ZodDefault':
+            return getZodSchema(zodType._def.innerType);
+        case 'ZodAny':
+        case 'ZodUnknown':
+        case 'ZodRecord':
+            return { type: 'object' };
+        default:
+            return { type: 'string' };
+    }
+}
+function isRequired(zodType) {
+    const typeName = zodType._def?.typeName;
+    return typeName !== 'ZodOptional' && typeName !== 'ZodDefault';
+}
+// Main entry point
+async function main() {
+    // Log to stderr (stdout is reserved for MCP protocol)
+    console.error('Kawa Intents MCP Server starting (Muninn IPC mode)...');
+    // Connect to Muninn before starting MCP transport
+    try {
+        await connectToMuninn();
+        console.error('Connected to Muninn');
+    }
+    catch (err) {
+        console.error(`Warning: ${err.message}`);
+        console.error('MCP server will start but tools will fail until Muninn is running.');
+    }
+    // Start the stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Kawa Intents MCP Server running');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map