@planningo/duul 1.0.0

package/build/tools/code-review.js

@@ -0,0 +1,178 @@
+import { CodeReviewInputSchema, CodeReviewOutputSchema, CodeReviewMcpOutputSchema, } from '../schemas/code-review.js';
+import { getCodeReviewSystemPrompt, formatCodeReviewUserMessage } from '../prompts/code-review-system.js';
+import { callReview } from '../services/reviewer.js';
+import { resolveWorkspaceScope, getGitDiff } from '../services/filesystem.js';
+import { computeIterationMeta, isIterationLimitExceeded } from '../services/review-limits.js';
+import { logUsage } from '../services/usage-logger.js';
+import { applyGates } from '../services/review-gates.js';
+const MAX_INLINE_DIFF_CHARS = 50_000;
+const ZERO_USAGE = { input_tokens: 0, output_tokens: 0, total_tokens: 0, api_calls: 0, provider: 'none', model: 'none', estimated_cost_usd: null };
+export function registerCodeReviewTool(server) {
+    server.registerTool('request_code_review', {
+        title: 'DUUL Code Review (Strict QA)',
+        description: 'DUUL Phase 2: Submit code for review by an LLM acting as a Strict QA Engineer. ' +
+            'Requires the approved plan for context. Returns blocking issues, vulnerabilities, ' +
+            'and optionally an optimized code snippet, or approval.',
+        inputSchema: CodeReviewInputSchema,
+        outputSchema: CodeReviewMcpOutputSchema,
+    }, async (input) => {
+        try {
+            const args = input;
+            const iterMeta = computeIterationMeta('code', args.iteration_count, args.max_review_iterations);
+            // Short-circuit if iteration limit exceeded
+            if (isIterationLimitExceeded('code', args.iteration_count, args.max_review_iterations)) {
+                console.error(`[duul] Code review iteration limit exceeded: ${args.iteration_count} > ${iterMeta.iteration_limit}`);
+                const limitResult = {
+                    verdict: 'REVISE',
+                    review_status: 'incomplete',
+                    confidence: 0,
+                    requires_human_review: true,
+                    logic_validation: `Iteration limit reached (${iterMeta.iteration_count}/${iterMeta.iteration_limit}). Human review required to continue.`,
+                    blocking_issues: [],
+                    merge_blockers: null,
+                    non_blocking_suggestions: [],
+                    vulnerabilities: [],
+                    optimized_snippet: null,
+                    follow_up_todos: null,
+                    missing_context: null,
+                    evidence_files: null,
+                    used_tools: null,
+                    tool_exhaustion_reason: null,
+                    user_original_request_echo: null,
+                    symptom_impact: null,
+                    symptom_match_notes: null,
+                    gates_tripped: null,
+                    review_id: '',
+                    ...iterMeta,
+                    token_usage: ZERO_USAGE,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(limitResult, null, 2) }],
+                    structuredContent: limitResult,
+                };
+            }
+            const scope = resolveWorkspaceScope(args);
+            // Auto-generate git diff if not provided
+            let gitDiff = args.git_diff;
+            if (!gitDiff && scope?.root && args.changed_files?.length) {
+                try {
+                    const diffResult = await getGitDiff(scope.root, args.git_diff_base ?? 'HEAD', args.changed_files, scope);
+                    if (diffResult && !diffResult.startsWith('Error') && !diffResult.startsWith('No differences')) {
+                        gitDiff = diffResult.length > MAX_INLINE_DIFF_CHARS
+                            ? diffResult.slice(0, MAX_INLINE_DIFF_CHARS) + `\n\n[truncated — diff exceeded ${MAX_INLINE_DIFF_CHARS} chars]`
+                            : diffResult;
+                    }
+                }
+                catch {
+                    // Diff generation is best-effort, continue without it
+                }
+            }
+            const systemPrompt = getCodeReviewSystemPrompt();
+            const userMessage = formatCodeReviewUserMessage(args.code, args.approved_plan, args.file_path, args.dependencies, args.relevant_code, args.notes_to_reviewer, {
+                workingDirectories: args.working_directories,
+                linkedRoots: args.linked_roots,
+                changedFiles: args.changed_files,
+                entrypoints: args.entrypoints,
+                artifactRefs: args.artifact_refs,
+                gitHeadSha: args.git_head_sha,
+                previousGitHeadSha: args.previous_git_head_sha,
+                workspaceName: args.workspace_name,
+                setupScriptPresent: args.setup_script_present,
+                runScriptPresent: args.run_script_present,
+                environmentFilesExpected: args.environment_files_expected,
+                gitDiff,
+            }, args.user_original_request);
+            const { parsed, reviewId, usage } = await callReview({
+                systemPrompt,
+                userMessage,
+                schemaName: 'code_review_output',
+                outputSchema: CodeReviewOutputSchema,
+                workspaceScope: scope,
+                previousReviewId: args.previous_review_id,
+                reviewerConfig: args.reviewer_config,
+                createFallback: (reason, usedTools) => ({
+                    verdict: 'REVISE',
+                    review_status: 'incomplete',
+                    confidence: 0,
+                    requires_human_review: true,
+                    logic_validation: `Review could not be completed — tool loop exhausted (${reason}).`,
+                    blocking_issues: [],
+                    merge_blockers: null,
+                    non_blocking_suggestions: [],
+                    vulnerabilities: [],
+                    optimized_snippet: null,
+                    follow_up_todos: null,
+                    missing_context: usedTools.length > 0 ? usedTools : ['No tools were called'],
+                    evidence_files: null,
+                    used_tools: usedTools,
+                    tool_exhaustion_reason: reason,
+                    user_original_request_echo: null,
+                    symptom_impact: null,
+                    symptom_match_notes: null,
+                    gates_tripped: null,
+                }),
+            });
+            // Invariant: APPROVE with blocking_issues is always wrong — override to REVISE
+            let verdict = parsed.verdict === 'APPROVE' && parsed.blocking_issues?.length > 0
+                ? 'REVISE'
+                : parsed.verdict;
+            if (verdict !== parsed.verdict) {
+                console.error(`[duul] Verdict overridden: APPROVE → REVISE (${parsed.blocking_issues.length} blocking issues)`);
+            }
+            // Post-LLM gates
+            const gates = applyGates({
+                phase: 'code',
+                userOriginalRequest: args.user_original_request,
+                notesToReviewer: args.notes_to_reviewer,
+                changedFiles: args.changed_files,
+                gitDiff,
+                artifactRefs: args.artifact_refs,
+                symptomImpact: parsed.symptom_impact,
+            });
+            let requires_human_review = parsed.requires_human_review;
+            let blocking_issues = parsed.blocking_issues;
+            if (gates.tripped.length > 0) {
+                if (gates.forcedVerdict === 'REVISE')
+                    verdict = 'REVISE';
+                if (gates.forcedHumanReview)
+                    requires_human_review = true;
+                blocking_issues = [...blocking_issues, ...gates.extraBlockingIssues];
+                console.error(`[duul] Code gates tripped: ${gates.tripped.join(', ')}`);
+            }
+            const result = {
+                ...parsed,
+                verdict,
+                requires_human_review,
+                blocking_issues,
+                gates_tripped: gates.tripped.length > 0 ? gates.tripped : null,
+                review_id: reviewId,
+                ...iterMeta,
+                token_usage: usage,
+            };
+            logUsage('code_review', result.token_usage, {
+                verdict,
+                review_id: reviewId,
+                iteration_count: iterMeta.iteration_count,
+                workspace_name: args.workspace_name,
+                gates_tripped: result.gates_tripped,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+                structuredContent: result,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[duul] code-review error: ${message}`);
+            return {
+                content: [{ type: 'text', text: `Code review failed: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/build/tools/execution-partition.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerExecutionPartitionTool(server: McpServer): void;

package/build/tools/execution-partition.js

@@ -0,0 +1,146 @@
+import { ExecutionPartitionInputSchema, ExecutionPartitionOutputSchema, ExecutionPartitionMcpOutputSchema, } from '../schemas/execution-partition.js';
+import { getExecutionPartitionSystemPrompt, formatExecutionPartitionUserMessage } from '../prompts/execution-partition-system.js';
+import { callReview } from '../services/reviewer.js';
+import { resolveWorkspaceScope } from '../services/filesystem.js';
+import { computeIterationMeta, isIterationLimitExceeded } from '../services/review-limits.js';
+import { logUsage } from '../services/usage-logger.js';
+const ZERO_USAGE = { input_tokens: 0, output_tokens: 0, total_tokens: 0, api_calls: 0, provider: 'none', model: 'none', estimated_cost_usd: null };
+export function registerExecutionPartitionTool(server) {
+    server.registerTool('request_execution_partition', {
+        title: 'DUUL Execution Partition (Project Manager)',
+        description: 'DUUL optional: Partition an approved plan into executable subtasks with dependency graph, ' +
+            'spawn strategy, and handoff contracts. Use after plan review approval to ' +
+            'determine whether work can be parallelized across multiple agents/workspaces.',
+        inputSchema: ExecutionPartitionInputSchema,
+        outputSchema: ExecutionPartitionMcpOutputSchema,
+    }, async (input) => {
+        try {
+            const args = input;
+            const iterMeta = computeIterationMeta('partition', args.iteration_count, args.max_review_iterations);
+            // Short-circuit if iteration limit exceeded
+            if (isIterationLimitExceeded('partition', args.iteration_count, args.max_review_iterations)) {
+                console.error(`[duul] Partition iteration limit exceeded: ${args.iteration_count} > ${iterMeta.iteration_limit}`);
+                const limitResult = {
+                    execution_mode: 'serial',
+                    rationale: `Iteration limit reached (${iterMeta.iteration_count}/${iterMeta.iteration_limit}). Human review required to continue.`,
+                    requires_human_checkpoint: true,
+                    human_checkpoint_reasons: [`Iteration limit reached — ${iterMeta.iteration_count}/${iterMeta.iteration_limit} iterations used.`],
+                    spawn_strategy: 'reuse_workspace',
+                    handoff_artifact_pattern: '.context/subtasks/{subtask_id}.json',
+                    subtask_result_schema_version: '1.0',
+                    subtasks: [{
+                            id: 'full-plan',
+                            title: 'Execute full plan serially (limit reached)',
+                            goal: args.approved_plan.slice(0, 200) + '...',
+                            can_run_in_parallel: false,
+                            depends_on: [],
+                            workspace_name_hint: 'main',
+                            spawn_strategy: 'reuse_workspace',
+                            scope: {
+                                working_directories: args.working_directories,
+                                changed_files: args.changed_files,
+                                entrypoints: args.entrypoints,
+                            },
+                            handoff_contract: [],
+                            completion_criteria: ['All items in the approved plan are implemented'],
+                            review_focus: ['Full plan implementation'],
+                            risk_level: 'medium',
+                        }],
+                    global_checkpoints: [],
+                    merge_order: ['full-plan'],
+                    retry_policy: {
+                        max_retries: 2,
+                        on_review_revise: 'retry_subtask',
+                        on_tool_exhaustion: 'retry_with_narrower_scope',
+                        on_conflict: 'serialize_and_retry',
+                        on_blocker: 'escalate_to_human',
+                        on_max_retries_exceeded: 'abort_subtask_and_report',
+                    },
+                    review_id: '',
+                    ...iterMeta,
+                    token_usage: ZERO_USAGE,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(limitResult, null, 2) }],
+                    structuredContent: limitResult,
+                };
+            }
+            const scope = resolveWorkspaceScope(args);
+            const systemPrompt = getExecutionPartitionSystemPrompt();
+            const userMessage = formatExecutionPartitionUserMessage(args.approved_plan, args.constraints, {
+                changedFiles: args.changed_files,
+                entrypoints: args.entrypoints,
+                artifactRefs: args.artifact_refs,
+                workingDirectories: args.working_directories,
+            }, args.max_parallelism);
+            const { parsed, reviewId, usage } = await callReview({
+                systemPrompt,
+                userMessage,
+                schemaName: 'execution_partition_output',
+                outputSchema: ExecutionPartitionOutputSchema,
+                workspaceScope: scope,
+                previousReviewId: args.previous_review_id,
+                reviewerConfig: args.reviewer_config,
+                createFallback: (_reason, _usedTools) => ({
+                    execution_mode: 'serial',
+                    rationale: 'Partition could not be completed — tool loop exhausted. Defaulting to serial execution.',
+                    requires_human_checkpoint: true,
+                    human_checkpoint_reasons: ['Partition was incomplete — human should verify before proceeding.'],
+                    spawn_strategy: 'reuse_workspace',
+                    handoff_artifact_pattern: '.context/subtasks/{subtask_id}.json',
+                    subtask_result_schema_version: '1.0',
+                    subtasks: [{
+                            id: 'full-plan',
+                            title: 'Execute full plan serially',
+                            goal: args.approved_plan.slice(0, 200) + '...',
+                            can_run_in_parallel: false,
+                            depends_on: [],
+                            workspace_name_hint: 'main',
+                            spawn_strategy: 'reuse_workspace',
+                            scope: {
+                                working_directories: args.working_directories,
+                                changed_files: args.changed_files,
+                                entrypoints: args.entrypoints,
+                            },
+                            handoff_contract: [],
+                            completion_criteria: ['All items in the approved plan are implemented'],
+                            review_focus: ['Full plan implementation'],
+                            risk_level: 'medium',
+                        }],
+                    global_checkpoints: [],
+                    merge_order: ['full-plan'],
+                    retry_policy: {
+                        max_retries: 2,
+                        on_review_revise: 'retry_subtask',
+                        on_tool_exhaustion: 'retry_with_narrower_scope',
+                        on_conflict: 'serialize_and_retry',
+                        on_blocker: 'escalate_to_human',
+                        on_max_retries_exceeded: 'abort_subtask_and_report',
+                    },
+                }),
+            });
+            const result = { ...parsed, review_id: reviewId, ...iterMeta, token_usage: usage };
+            logUsage('execution_partition', result.token_usage, {
+                review_id: reviewId,
+                iteration_count: iterMeta.iteration_count,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+                structuredContent: result,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[duul] execution-partition error: ${message}`);
+            return {
+                content: [{ type: 'text', text: `Execution partition failed: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/build/tools/plan-review.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerPlanReviewTool(server: McpServer): void;

package/build/tools/plan-review.js

@@ -0,0 +1,183 @@
+import { PlanReviewInputSchema, PlanReviewOutputSchema, PlanReviewMcpOutputSchema, } from '../schemas/plan-review.js';
+import { getPlanReviewSystemPrompt, formatPlanReviewUserMessage } from '../prompts/plan-review-system.js';
+import { callReview } from '../services/reviewer.js';
+import { resolveWorkspaceScope, getGitDiff } from '../services/filesystem.js';
+import { computeIterationMeta, isIterationLimitExceeded } from '../services/review-limits.js';
+import { logUsage } from '../services/usage-logger.js';
+import { applyGates } from '../services/review-gates.js';
+const MAX_INLINE_DIFF_CHARS = 50_000;
+const ZERO_USAGE = { input_tokens: 0, output_tokens: 0, total_tokens: 0, api_calls: 0, provider: 'none', model: 'none', estimated_cost_usd: null };
+export function registerPlanReviewTool(server) {
+    server.registerTool('request_plan_review', {
+        title: 'DUUL Plan Review (Senior Architect)',
+        description: 'DUUL Phase 1: Submit a development plan for review by an LLM acting as a Senior Architect. ' +
+            'Returns structured feedback with blocking issues, edge cases, and implementation checklist, or approval.',
+        inputSchema: PlanReviewInputSchema,
+        outputSchema: PlanReviewMcpOutputSchema,
+    }, async (input) => {
+        try {
+            const args = input;
+            const iterMeta = computeIterationMeta('plan', args.iteration_count, args.max_review_iterations);
+            // Short-circuit if iteration limit exceeded
+            if (isIterationLimitExceeded('plan', args.iteration_count, args.max_review_iterations)) {
+                console.error(`[duul] Plan review iteration limit exceeded: ${args.iteration_count} > ${iterMeta.iteration_limit}`);
+                const limitResult = {
+                    verdict: 'REVISE',
+                    review_status: 'incomplete',
+                    confidence: 0,
+                    requires_human_review: true,
+                    architectural_analysis: `Iteration limit reached (${iterMeta.iteration_count}/${iterMeta.iteration_limit}). Human review required to continue.`,
+                    blocking_issues: [],
+                    merge_blockers: null,
+                    non_blocking_suggestions: [],
+                    edge_cases: [],
+                    checklist_for_implementation: [],
+                    follow_up_todos: null,
+                    missing_context: null,
+                    evidence_files: null,
+                    used_tools: null,
+                    tool_exhaustion_reason: null,
+                    parallelization_hint: null,
+                    coordination_risks: null,
+                    recommended_subtask_boundaries: null,
+                    user_original_request_echo: null,
+                    symptom_impact: null,
+                    symptom_match_notes: null,
+                    gates_tripped: null,
+                    review_id: '',
+                    ...iterMeta,
+                    token_usage: ZERO_USAGE,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(limitResult, null, 2) }],
+                    structuredContent: limitResult,
+                };
+            }
+            const scope = resolveWorkspaceScope(args);
+            // Auto-generate git diff if not provided
+            let gitDiff = args.git_diff;
+            if (!gitDiff && scope?.root && args.changed_files?.length) {
+                try {
+                    const diffResult = await getGitDiff(scope.root, args.git_diff_base ?? 'HEAD', args.changed_files, scope);
+                    if (diffResult && !diffResult.startsWith('Error') && !diffResult.startsWith('No differences')) {
+                        gitDiff = diffResult.length > MAX_INLINE_DIFF_CHARS
+                            ? diffResult.slice(0, MAX_INLINE_DIFF_CHARS) + `\n\n[truncated — diff exceeded ${MAX_INLINE_DIFF_CHARS} chars]`
+                            : diffResult;
+                    }
+                }
+                catch {
+                    // Diff generation is best-effort, continue without it
+                }
+            }
+            const systemPrompt = getPlanReviewSystemPrompt();
+            const userMessage = formatPlanReviewUserMessage(args.plan, args.project_context, args.constraints, args.notes_to_reviewer, {
+                workingDirectories: args.working_directories,
+                linkedRoots: args.linked_roots,
+                changedFiles: args.changed_files,
+                entrypoints: args.entrypoints,
+                artifactRefs: args.artifact_refs,
+                gitHeadSha: args.git_head_sha,
+                previousGitHeadSha: args.previous_git_head_sha,
+                workspaceName: args.workspace_name,
+                setupScriptPresent: args.setup_script_present,
+                runScriptPresent: args.run_script_present,
+                environmentFilesExpected: args.environment_files_expected,
+                gitDiff,
+            }, args.user_original_request);
+            const { parsed, reviewId, usage } = await callReview({
+                systemPrompt,
+                userMessage,
+                schemaName: 'plan_review_output',
+                outputSchema: PlanReviewOutputSchema,
+                workspaceScope: scope,
+                previousReviewId: args.previous_review_id,
+                reviewerConfig: args.reviewer_config,
+                createFallback: (reason, usedTools) => ({
+                    verdict: 'REVISE',
+                    review_status: 'incomplete',
+                    confidence: 0,
+                    requires_human_review: true,
+                    architectural_analysis: `Review could not be completed — tool loop exhausted (${reason}).`,
+                    blocking_issues: [],
+                    merge_blockers: null,
+                    non_blocking_suggestions: [],
+                    edge_cases: [],
+                    checklist_for_implementation: [],
+                    follow_up_todos: null,
+                    missing_context: usedTools.length > 0 ? usedTools : ['No tools were called'],
+                    evidence_files: null,
+                    used_tools: usedTools,
+                    tool_exhaustion_reason: reason,
+                    parallelization_hint: null,
+                    coordination_risks: null,
+                    recommended_subtask_boundaries: null,
+                    user_original_request_echo: null,
+                    symptom_impact: null,
+                    symptom_match_notes: null,
+                    gates_tripped: null,
+                }),
+            });
+            // Invariant: APPROVE with blocking_issues is always wrong — override to REVISE
+            let verdict = parsed.verdict === 'APPROVE' && parsed.blocking_issues?.length > 0
+                ? 'REVISE'
+                : parsed.verdict;
+            if (verdict !== parsed.verdict) {
+                console.error(`[duul] Verdict overridden: APPROVE → REVISE (${parsed.blocking_issues.length} blocking issues)`);
+            }
+            // Post-LLM gates
+            const gates = applyGates({
+                phase: 'plan',
+                userOriginalRequest: args.user_original_request,
+                notesToReviewer: args.notes_to_reviewer,
+                changedFiles: args.changed_files,
+                gitDiff,
+                artifactRefs: args.artifact_refs,
+                symptomImpact: parsed.symptom_impact,
+            });
+            let requires_human_review = parsed.requires_human_review;
+            let blocking_issues = parsed.blocking_issues;
+            if (gates.tripped.length > 0) {
+                if (gates.forcedVerdict === 'REVISE')
+                    verdict = 'REVISE';
+                if (gates.forcedHumanReview)
+                    requires_human_review = true;
+                blocking_issues = [...blocking_issues, ...gates.extraBlockingIssues];
+                console.error(`[duul] Plan gates tripped: ${gates.tripped.join(', ')}`);
+            }
+            const result = {
+                ...parsed,
+                verdict,
+                requires_human_review,
+                blocking_issues,
+                gates_tripped: gates.tripped.length > 0 ? gates.tripped : null,
+                review_id: reviewId,
+                ...iterMeta,
+                token_usage: usage,
+            };
+            logUsage('plan_review', result.token_usage, {
+                verdict,
+                review_id: reviewId,
+                iteration_count: iterMeta.iteration_count,
+                workspace_name: args.workspace_name,
+                gates_tripped: result.gates_tripped,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+                structuredContent: result,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[duul] plan-review error: ${message}`);
+            return {
+                content: [{ type: 'text', text: `Plan review failed: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@planningo/duul",
+  "version": "1.0.0",
+  "description": "DUUL — Dual-phase Upfront-plan & Unit-verify Loop. MCP server for LLM peer review of plans and code.",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "duul": "build/index.js"
+  },
+  "files": [
+    "build",
+    "!build/__tests__",
+    "!build/**/*.test.js",
+    "!build/**/*.test.d.ts",
+    "README.md",
+    "README.ko.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "test": "tsc && node --test build/services/*.test.js build/__tests__/*.test.js",
+    "token-report": "node scripts/token-report.mjs",
+    "prepublishOnly": "npm run build",
+    "release": "changeset publish"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "claude-code",
+    "anthropic",
+    "openai",
+    "llm",
+    "code-review",
+    "peer-review",
+    "duul"
+  ],
+  "author": "Planningo",
+  "license": "MIT",
+  "homepage": "https://github.com/Planningo/duul#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Planningo/duul.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Planningo/duul/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "openai": "^6.1.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.31.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0"
+  }
+}