@co-syn/forest 0.1.0

package/README.md

@@ -0,0 +1,102 @@
+# @co-syn/forest
+
+Bridge your Claude Code sessions with your team. Share context, sync plans, track tasks — one command to set up.
+
+## Quick start
+
+```bash
+npx @co-syn/forest init --token forestpat_YOUR_TOKEN
+```
+
+That's it. This registers the MCP server, configures the plan sync hook, and saves your credentials.
+
+## What it does
+
+### MCP Tools (Claude calls these)
+
+| Tool | Description |
+|------|-------------|
+| `forest_sync` | Share a summary of your session with the team via Slack |
+| `forest_tasks` | List active tasks from Forest |
+| `forest_update` | Update a task's status or add notes |
+
+### Plan Sync Hook (automatic)
+
+When you exit plan mode in Claude Code ("Accept Edits"), the plan markdown is automatically sent to Forest. From there, Forest can:
+- Match the plan to active tasks
+- Post to your team's Slack channel
+- Update project context
+
+## Setup
+
+### 1. Get your token
+
+Generate a personal API token from the Forest web app settings page.
+
+### 2. Run init
+
+```bash
+npx @co-syn/forest init --token forestpat_YOUR_TOKEN
+```
+
+For a custom backend URL:
+
+```bash
+npx @co-syn/forest init --token forestpat_YOUR_TOKEN --api-url https://your-backend.example.com
+```
+
+### 3. Use it
+
+In Claude Code, just ask naturally:
+
+- "sync what we did to the team"
+- "share this with @john on #engineering"
+- "show me active tasks"
+- "mark the auth task as done"
+
+Plans sync automatically when you accept edits from plan mode — no action needed.
+
+## How it works
+
+```
+npx @co-syn/forest init
+  ├── Saves token to ~/.config/forest/config.json
+  ├── Registers MCP server with Claude Code
+  └── Adds ExitPlanMode hook to ~/.claude/settings.json
+
+During a session:
+  Claude Code ←─stdio──→ forest mcp (MCP server, local process)
+                              │
+                         HTTPS + Bearer token
+                              │
+                              ▼
+                     Forest Backend (your org)
+                        ├── Slack
+                        ├── Tasks DB
+                        └── Normalized Events
+
+On "Accept Edits":
+  ExitPlanMode hook fires → forest hook plan-exit
+    → reads transcript → extracts plan markdown
+    → POST /mcp/plan to Forest backend
+```
+
+## Local development
+
+```bash
+npx @co-syn/forest init --token forestpat_YOUR_TOKEN --api-url http://localhost:8787
+```
+
+Or run the MCP server directly:
+
+```bash
+FOREST_API_TOKEN=forestpat_... FOREST_API_URL=http://localhost:8787 node packages/forest-mcp/build/mcp.js
+```
+
+## CLI reference
+
+```
+npx @co-syn/forest init --token <token>   # Set up everything
+npx @co-syn/forest mcp                    # Start MCP server (used by Claude Code)
+npx @co-syn/forest hook plan-exit         # Run plan-exit hook (used by Claude Code)
+```

package/build/cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Forest CLI — setup tool for Forest + Claude Code integration.
+ *
+ * Usage:
+ *   npx @co-syn/forest init --token forestpat_abc123
+ *   npx @co-syn/forest init --token forestpat_abc123 --api-url https://api.example.com
+ */
+export {};

package/build/cli.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * Forest CLI — setup tool for Forest + Claude Code integration.
+ *
+ * Usage:
+ *   npx @co-syn/forest init --token forestpat_abc123
+ *   npx @co-syn/forest init --token forestpat_abc123 --api-url https://api.example.com
+ */
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { execSync } from "child_process";
+import { writeConfigFile, resolveConfig } from "./lib/config.js";
+import { forestApi } from "./lib/api.js";
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i].startsWith("--") && i + 1 < argv.length) {
+            const key = argv[i].slice(2);
+            args[key] = argv[i + 1];
+            i++;
+        }
+    }
+    return args;
+}
+function readClaudeSettings() {
+    const settingsPath = join(homedir(), ".claude", "settings.json");
+    try {
+        return JSON.parse(readFileSync(settingsPath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeClaudeSettings(settings) {
+    const settingsPath = join(homedir(), ".claude", "settings.json");
+    mkdirSync(join(homedir(), ".claude"), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+function mergeHookConfig(settings) {
+    const hooks = (settings.hooks ?? {});
+    const preToolUse = (hooks.PreToolUse ?? []);
+    // Check if we already have an ExitPlanMode hook
+    const existing = preToolUse.find((h) => h.matcher === "ExitPlanMode");
+    if (existing) {
+        console.log("  Hook already configured for ExitPlanMode — skipping");
+        return;
+    }
+    preToolUse.push({
+        matcher: "ExitPlanMode",
+        hooks: [
+            {
+                type: "command",
+                command: "npx @co-syn/forest hook plan-exit",
+                async: true,
+            },
+        ],
+    });
+    hooks.PreToolUse = preToolUse;
+    settings.hooks = hooks;
+}
+async function init(args) {
+    const token = args.token;
+    const apiUrl = args["api-url"] ?? "https://api.forestworks.ai";
+    if (!token) {
+        console.error("Usage: npx @co-syn/forest init --token <forestpat_...>");
+        console.error("");
+        console.error("Get your token from the Forest web app settings page.");
+        process.exit(1);
+    }
+    if (!token.startsWith("forestpat_")) {
+        console.error("Invalid token format. Tokens start with 'forestpat_'.");
+        process.exit(1);
+    }
+    console.log("Setting up Forest for Claude Code...\n");
+    // 1. Write config file
+    console.log("1. Saving credentials...");
+    writeConfigFile({ token, apiUrl });
+    console.log("   Saved to ~/.config/forest/config.json\n");
+    // 2. Validate token by calling the tasks endpoint
+    console.log("2. Validating token...");
+    try {
+        const config = resolveConfig();
+        await forestApi(config, "/tasks");
+        console.log("   Token is valid.\n");
+    }
+    catch (err) {
+        console.error(`   Token validation failed: ${err instanceof Error ? err.message : String(err)}`);
+        console.error("   The token was saved but may not work. Check your token and API URL.");
+        console.log("");
+    }
+    // 3. Register MCP server with Claude Code
+    console.log("3. Registering MCP server...");
+    try {
+        execSync(`claude mcp add forest -s user -- npx @co-syn/forest mcp`, { stdio: "pipe" });
+        console.log("   MCP server registered.\n");
+    }
+    catch {
+        console.log("   Could not auto-register. Run manually:");
+        console.log("   claude mcp add forest -s user -- npx @co-syn/forest mcp\n");
+    }
+    // 4. Add hook config
+    console.log("4. Configuring plan sync hook...");
+    const settings = readClaudeSettings();
+    mergeHookConfig(settings);
+    writeClaudeSettings(settings);
+    console.log("   Hook added to ~/.claude/settings.json\n");
+    console.log("Done! Forest is ready.\n");
+    console.log("What happens now:");
+    console.log("  - Claude Code can share session context via forest_sync");
+    console.log("  - Plans auto-sync to Forest when you accept edits");
+    console.log("  - View and update tasks with forest_tasks / forest_update");
+}
+// --- Entrypoint ---
+const subcommand = process.argv[2];
+const args = parseArgs(process.argv.slice(3));
+switch (subcommand) {
+    case "init":
+        init(args).catch((err) => {
+            console.error("Setup failed:", err);
+            process.exit(1);
+        });
+        break;
+    case "mcp":
+        // Forward to MCP server — dynamic import to avoid loading MCP deps for other commands
+        import("./mcp.js").catch((err) => {
+            console.error("Failed to start MCP server:", err);
+            process.exit(1);
+        });
+        break;
+    case "hook":
+        // Forward to hook handler
+        // Re-invoke with correct argv position
+        process.argv = [process.argv[0], process.argv[1], ...process.argv.slice(3)];
+        import("./hook.js").catch((err) => {
+            console.error("Hook error:", err);
+            process.exit(0); // don't block
+        });
+        break;
+    default:
+        console.log("Forest CLI — Claude Code integration\n");
+        console.log("Commands:");
+        console.log("  init --token <token>   Set up Forest for Claude Code");
+        console.log("  mcp                    Start the MCP server (used by Claude Code)");
+        console.log("  hook <name>            Run a hook handler (used by Claude Code)");
+        console.log("");
+        console.log("Get started:");
+        console.log("  npx @co-syn/forest init --token forestpat_YOUR_TOKEN");
+        break;
+}

package/build/hook.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Forest hook handler — runs when a Claude Code hook fires.
+ *
+ * Usage:
+ *   forest-hook plan-exit    (called by PreToolUse hook on ExitPlanMode)
+ *
+ * Reads the hook event JSON from stdin, extracts the plan from the
+ * conversation transcript, and POSTs it to the Forest backend.
+ */
+export {};

package/build/hook.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * Forest hook handler — runs when a Claude Code hook fires.
+ *
+ * Usage:
+ *   forest-hook plan-exit    (called by PreToolUse hook on ExitPlanMode)
+ *
+ * Reads the hook event JSON from stdin, extracts the plan from the
+ * conversation transcript, and POSTs it to the Forest backend.
+ */
+import { readFileSync } from "fs";
+import { resolveConfig } from "./lib/config.js";
+import { forestApi } from "./lib/api.js";
+function extractText(content) {
+    if (!content)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((block) => block.type === "text" && block.text)
+        .map((block) => block.text)
+        .join("\n");
+}
+function extractPlanFromTranscript(transcriptPath) {
+    let raw;
+    try {
+        raw = readFileSync(transcriptPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const lines = raw.split("\n").filter(Boolean);
+    const entries = [];
+    for (const line of lines) {
+        try {
+            entries.push(JSON.parse(line));
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    if (entries.length === 0)
+        return null;
+    // Find the last EnterPlanMode — everything after that is the plan
+    let planStartIndex = -1;
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const e = entries[i];
+        const isEnterPlan = e.tool_name === "EnterPlanMode" ||
+            e.name === "EnterPlanMode" ||
+            (e.type === "tool_use" && e.name === "EnterPlanMode") ||
+            (e.message?.content &&
+                Array.isArray(e.message.content) &&
+                e.message.content.some((block) => block.type === "tool_use" && block.name === "EnterPlanMode"));
+        if (isEnterPlan) {
+            planStartIndex = i;
+            break;
+        }
+    }
+    if (planStartIndex === -1) {
+        // No EnterPlanMode found — grab the last few assistant messages as fallback
+        const lastAssistant = entries
+            .filter((e) => e.role === "assistant" ||
+            e.message?.role === "assistant" ||
+            e.type === "assistant")
+            .slice(-5);
+        if (lastAssistant.length === 0)
+            return null;
+        return lastAssistant
+            .map((e) => extractText(e.message?.content ?? e.content))
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    // Collect assistant text content from planStartIndex onward
+    const planParts = [];
+    for (let i = planStartIndex + 1; i < entries.length; i++) {
+        const e = entries[i];
+        const isAssistant = e.role === "assistant" ||
+            e.message?.role === "assistant" ||
+            e.type === "assistant";
+        if (!isAssistant)
+            continue;
+        const text = extractText(e.message?.content ?? e.content);
+        if (text.trim())
+            planParts.push(text);
+    }
+    return planParts.length > 0 ? planParts.join("\n\n") : null;
+}
+async function handlePlanExit() {
+    const config = resolveConfig();
+    if (!config) {
+        process.stderr.write("Forest not configured. Run: npx @co-syn/forest init --token <token>\n");
+        process.exit(0); // exit 0 so we don't block the tool
+    }
+    // Read hook event from stdin
+    let eventJson;
+    try {
+        eventJson = readFileSync("/dev/stdin", "utf-8");
+    }
+    catch {
+        // stdin not available — nothing to do
+        process.exit(0);
+    }
+    let event;
+    try {
+        event = JSON.parse(eventJson);
+    }
+    catch {
+        process.exit(0);
+    }
+    if (!event.transcript_path) {
+        process.exit(0);
+    }
+    const plan = extractPlanFromTranscript(event.transcript_path);
+    if (!plan?.trim()) {
+        process.exit(0);
+    }
+    try {
+        await forestApi(config, "/plan", {
+            method: "POST",
+            body: {
+                plan,
+                sessionId: event.session_id,
+                cwd: event.cwd,
+            },
+        });
+    }
+    catch (err) {
+        // Log but don't block — this is async and best-effort
+        process.stderr.write(`Forest plan sync failed: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+}
+// --- Entrypoint ---
+const subcommand = process.argv[2];
+switch (subcommand) {
+    case "plan-exit":
+        handlePlanExit().catch(() => process.exit(0));
+        break;
+    default:
+        console.error(`Unknown hook: ${subcommand}`);
+        console.error("Available hooks: plan-exit");
+        process.exit(0); // don't block
+}

package/build/lib/api.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared HTTP client for Forest backend API.
+ * Used by both the MCP server and the hook script.
+ */
+import type { ForestConfig } from "./config.js";
+export declare function forestApi<T>(config: ForestConfig, path: string, options?: {
+    method?: string;
+    body?: unknown;
+}): Promise<T>;

package/build/lib/api.js

@@ -0,0 +1,20 @@
+/**
+ * Shared HTTP client for Forest backend API.
+ * Used by both the MCP server and the hook script.
+ */
+export async function forestApi(config, path, options = {}) {
+    const url = `${config.apiUrl}/mcp${path}`;
+    const response = await fetch(url, {
+        method: options.method ?? "GET",
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+            "Content-Type": "application/json",
+        },
+        ...(options.body ? { body: JSON.stringify(options.body) } : {}),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Forest API error (${response.status}): ${text}`);
+    }
+    return response.json();
+}

package/build/lib/config.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared config — reads Forest credentials from:
+ *   1. Environment variables (FOREST_API_TOKEN, FOREST_API_URL)
+ *   2. Config file (~/.config/forest/config.json)
+ *
+ * The CLI `forest init` writes the config file. Both the MCP server
+ * and the hook script use this module to resolve credentials.
+ */
+export interface ForestConfig {
+    token: string;
+    apiUrl: string;
+}
+export declare function readConfigFile(): Partial<ForestConfig>;
+export declare function writeConfigFile(config: ForestConfig): void;
+/**
+ * Resolve config: env vars take priority, then config file.
+ * Returns null if no token is found.
+ */
+export declare function resolveConfig(): ForestConfig | null;

package/build/lib/config.js

@@ -0,0 +1,41 @@
+/**
+ * Shared config — reads Forest credentials from:
+ *   1. Environment variables (FOREST_API_TOKEN, FOREST_API_URL)
+ *   2. Config file (~/.config/forest/config.json)
+ *
+ * The CLI `forest init` writes the config file. Both the MCP server
+ * and the hook script use this module to resolve credentials.
+ */
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+const DEFAULT_API_URL = "https://api.forestworks.ai";
+function configPath() {
+    return join(homedir(), ".config", "forest", "config.json");
+}
+export function readConfigFile() {
+    try {
+        const raw = readFileSync(configPath(), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function writeConfigFile(config) {
+    const path = configPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+/**
+ * Resolve config: env vars take priority, then config file.
+ * Returns null if no token is found.
+ */
+export function resolveConfig() {
+    const file = readConfigFile();
+    const token = process.env.FOREST_API_TOKEN || file.token;
+    const apiUrl = process.env.FOREST_API_URL || file.apiUrl || DEFAULT_API_URL;
+    if (!token)
+        return null;
+    return { token, apiUrl };
+}

package/build/mcp.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Forest MCP Server
+ *
+ * Bridges Claude Code sessions with your team via Forest.
+ * Allows syncing conversation context to Slack, viewing tasks,
+ * and updating task status — all from within Claude Code.
+ *
+ * Reads credentials from:
+ *   1. Env vars: FOREST_API_TOKEN, FOREST_API_URL
+ *   2. Config file: ~/.config/forest/config.json (written by `forest init`)
+ */
+export {};

package/build/mcp.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+/**
+ * Forest MCP Server
+ *
+ * Bridges Claude Code sessions with your team via Forest.
+ * Allows syncing conversation context to Slack, viewing tasks,
+ * and updating task status — all from within Claude Code.
+ *
+ * Reads credentials from:
+ *   1. Env vars: FOREST_API_TOKEN, FOREST_API_URL
+ *   2. Config file: ~/.config/forest/config.json (written by `forest init`)
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { resolveConfig } from "./lib/config.js";
+import { forestApi } from "./lib/api.js";
+const config = resolveConfig();
+if (!config) {
+    console.error("Forest not configured. Run: npx @co-syn/forest init --token <token>");
+    console.error("Or set FOREST_API_TOKEN environment variable.");
+    process.exit(1);
+}
+// --- MCP Server ---
+const server = new McpServer({
+    name: "forest",
+    version: "0.1.0",
+});
+// Tool 1: forest_sync — Share session context with the team via Slack
+server.tool("forest_sync", "Share a summary of your current work session with your team via Slack. " +
+    "Use this when the user wants to share what they've been working on, " +
+    "communicate decisions, or ping someone about progress. " +
+    "You should summarize the relevant parts of the conversation as the summary parameter.", {
+    summary: z
+        .string()
+        .describe("A clear, concise summary of what was accomplished, decided, or discussed in this session. " +
+        "Include key decisions, code changes, blockers, or questions. " +
+        "Write it as if addressing the team — not as a chat transcript."),
+    recipients: z
+        .array(z.string())
+        .optional()
+        .describe("Slack usernames or display names to @mention in the message (e.g. ['john', 'sarah'])"),
+    channel: z
+        .string()
+        .optional()
+        .describe("Slack channel name to post to (e.g. 'engineering', 'general'). " +
+        "If omitted, posts to the team's default channel."),
+    taskId: z
+        .string()
+        .optional()
+        .describe("Forest task ID to link this sync to. If provided, the message will reference the task."),
+}, async (args) => {
+    try {
+        const result = await forestApi(config, "/sync", {
+            method: "POST",
+            body: {
+                summary: args.summary,
+                recipients: args.recipients,
+                channel: args.channel,
+                taskId: args.taskId,
+            },
+        });
+        const parts = ["Synced to Slack"];
+        if (result.channel)
+            parts.push(`in #${result.channel}`);
+        if (args.recipients?.length)
+            parts.push(`(mentioned: ${args.recipients.join(", ")})`);
+        return {
+            content: [{ type: "text", text: parts.join(" ") }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to sync: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Tool 2: forest_tasks — List active tasks for context
+server.tool("forest_tasks", "List active tasks from Forest for your team. " +
+    "Use this to find task IDs when the user wants to link their work to a task, " +
+    "or to understand what the team is working on.", {
+    goalId: z
+        .string()
+        .optional()
+        .describe("Filter tasks by goal ID. If omitted, returns all active tasks."),
+    status: z
+        .string()
+        .optional()
+        .describe("Filter by status (unstarted, in_progress, blocked, at_risk, in_review). " +
+        "If omitted, returns all non-completed tasks."),
+}, async (args) => {
+    try {
+        const params = new URLSearchParams();
+        if (args.goalId)
+            params.set("goalId", args.goalId);
+        if (args.status)
+            params.set("status", args.status);
+        const query = params.toString();
+        const result = await forestApi(config, `/tasks${query ? `?${query}` : ""}`);
+        if (result.tasks.length === 0) {
+            return {
+                content: [
+                    { type: "text", text: "No active tasks found." },
+                ],
+            };
+        }
+        const formatted = result.tasks
+            .map((t) => `- [${t.status}] ${t.title} (ID: ${t.id})` +
+            (t.goalTitle ? `\n  Goal: ${t.goalTitle}` : "") +
+            (t.assignee ? `\n  Assignee: ${t.assignee}` : ""))
+            .join("\n\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Active tasks:\n\n${formatted}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to fetch tasks: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Tool 3: forest_update — Update a task's status or add notes
+server.tool("forest_update", "Update a Forest task with progress, status changes, or notes from your session. " +
+    "Use this when the user has completed work on a task or wants to record progress.", {
+    taskId: z.string().describe("The Forest task ID to update."),
+    status: z
+        .string()
+        .optional()
+        .describe("New status: unstarted, in_progress, blocked, at_risk, in_review, done, deferred, dropped"),
+    notes: z
+        .string()
+        .optional()
+        .describe("Progress notes to add to the task. Summarize what was done, " +
+        "decisions made, or blockers encountered."),
+}, async (args) => {
+    try {
+        const result = await forestApi(config, `/tasks/${args.taskId}`, {
+            method: "POST",
+            body: {
+                status: args.status,
+                notes: args.notes,
+            },
+        });
+        const parts = [`Updated task: ${result.task.title}`];
+        if (args.status)
+            parts.push(`Status → ${result.task.status}`);
+        if (args.notes)
+            parts.push("Notes added");
+        return {
+            content: [{ type: "text", text: parts.join(". ") }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to update task: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// --- Start ---
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Forest MCP server running on stdio");
+}
+main().catch((err) => {
+    console.error("Forest MCP server failed to start:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@co-syn/forest",
+  "version": "0.1.0",
+  "description": "Forest CLI — sync Claude Code sessions, plans, and tasks with your team",
+  "keywords": [
+    "claude-code",
+    "forest",
+    "mcp",
+    "slack",
+    "team-sync"
+  ],
+  "homepage": "https://forestworks.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/co-syn/forest.git",
+    "directory": "packages/forest-mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/co-syn/forest/issues"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "forest": "build/cli.js",
+    "forest-mcp": "build/mcp.js",
+    "forest-hook": "build/hook.js"
+  },
+  "files": [
+    "build"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && chmod 755 build/cli.js build/mcp.js build/hook.js",
+    "dev": "tsx src/mcp.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0"
+  }
+}