@j0hanz/code-assistant 0.9.0

package/dist/prompts/index.js

@@ -0,0 +1,96 @@
+import { completable } from '@modelcontextprotocol/sdk/server/completable.js';
+import { z } from 'zod';
+import { toInlineCode } from '../lib/format.js';
+import { getToolContract, getToolContractNames, INSPECTION_FOCUS_AREAS, } from '../lib/tools.js';
+export const PROMPT_DEFINITIONS = [
+    {
+        name: 'get-help',
+        title: 'Get Help',
+        description: 'Server instructions.',
+    },
+    {
+        name: 'review-guide',
+        title: 'Review Guide',
+        description: 'Workflow guide for tool/focus area.',
+    },
+];
+const TOOLS = getToolContractNames();
+const TOOL_DESCRIPTION_TEXT = 'Select tool for review guide.';
+const FOCUS_DESCRIPTION_TEXT = 'Select focus area.';
+const FOCUS_AREA_GUIDES = {
+    security: 'Focus: Injection, Auth, Crypto, OWASP.',
+    correctness: 'Focus: Logic, Edge Cases, Types.',
+    performance: 'Focus: Complexity, Memory, Latency.',
+    regressions: 'Focus: Behavior Changes, Breaking APIs.',
+    tests: 'Focus: Coverage, Error Paths.',
+    maintainability: 'Focus: Complexity, Readability, Patterns.',
+    concurrency: 'Focus: Races, Deadlocks, Atomicity.',
+};
+function isFocusArea(value) {
+    return INSPECTION_FOCUS_AREAS.includes(value);
+}
+function completeByPrefix(values, prefix) {
+    return values.filter((value) => value.startsWith(prefix));
+}
+function getToolGuide(tool) {
+    const contract = getToolContract(tool);
+    if (!contract) {
+        return `Use ${toInlineCode(tool)} to analyze your code changes.`;
+    }
+    const modelLine = buildToolModelLine(contract);
+    return `Tool: ${contract.name}\n${modelLine}\nOutput: ${contract.outputShape}\nUse: ${contract.purpose}`;
+}
+function buildToolModelLine(contract) {
+    if (contract.thinkingLevel !== undefined) {
+        return `Model: ${contract.model} (thinking level ${contract.thinkingLevel}, output cap ${contract.maxOutputTokens}).`;
+    }
+    return `Model: ${contract.model} (output cap ${contract.maxOutputTokens}).`;
+}
+function createPromptResponse(description, text) {
+    return {
+        description,
+        messages: [
+            {
+                role: 'user',
+                content: { type: 'text', text },
+            },
+        ],
+    };
+}
+function getFocusAreaGuide(focusArea) {
+    return isFocusArea(focusArea)
+        ? FOCUS_AREA_GUIDES[focusArea]
+        : `Focus on ${focusArea} concerns.`;
+}
+function registerHelpPrompt(server, instructions) {
+    const def = PROMPT_DEFINITIONS[0];
+    server.registerPrompt(def.name, {
+        title: def.title,
+        description: def.description,
+    }, () => createPromptResponse(def.description, instructions));
+}
+function buildReviewGuideText(tool, focusArea) {
+    const toolCode = toInlineCode(tool);
+    return (`# Guide: ${tool} / ${focusArea}\n\n` +
+        `## Tool: ${toolCode}\n${getToolGuide(tool)}\n\n` +
+        `## Focus: ${focusArea}\n${getFocusAreaGuide(focusArea)}`);
+}
+function registerReviewGuidePrompt(server) {
+    const def = PROMPT_DEFINITIONS[1];
+    server.registerPrompt(def.name, {
+        title: def.title,
+        description: def.description,
+        argsSchema: {
+            tool: completable(z.string().optional().describe(TOOL_DESCRIPTION_TEXT), (value) => completeByPrefix(TOOLS, value ?? '')),
+            focusArea: completable(z.string().optional().describe(FOCUS_DESCRIPTION_TEXT), (value) => completeByPrefix(INSPECTION_FOCUS_AREAS, value ?? '')),
+        },
+    }, (args) => {
+        const selectedTool = args.tool ?? TOOLS[0] ?? 'analyze_pr_impact';
+        const selectedFocus = args.focusArea ?? INSPECTION_FOCUS_AREAS[0];
+        return createPromptResponse(`Code review guide: ${selectedTool} / ${selectedFocus}`, buildReviewGuideText(selectedTool, selectedFocus));
+    });
+}
+export function registerAllPrompts(server, instructions) {
+    registerHelpPrompt(server, instructions);
+    registerReviewGuidePrompt(server);
+}

package/dist/resources/index.d.ts

@@ -0,0 +1,12 @@
+import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export interface StaticResourceDef {
+    id: string;
+    uri: string;
+    title: string;
+    description: string;
+    priority: number;
+    content?: () => string;
+}
+export declare const STATIC_RESOURCES: readonly StaticResourceDef[];
+export declare const DIFF_RESOURCE_DESCRIPTION = "The most recently generated diff, cached by generate_diff. Read by all review tools automatically.";
+export declare function registerAllResources(server: McpServer, instructions: string): void;

package/dist/resources/index.js

@@ -0,0 +1,115 @@
+import { ResourceTemplate, } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { DIFF_RESOURCE_URI, getDiff } from '../lib/diff.js';
+import { buildServerConfig } from './server-config.js';
+import { buildToolCatalog } from './tool-catalog.js';
+import { getToolInfo, getToolInfoNames } from './tool-info.js';
+import { buildWorkflowGuide } from './workflows.js';
+const RESOURCE_MIME_TYPE = 'text/markdown';
+const PATCH_MIME_TYPE = 'text/x-patch';
+const RESOURCE_AUDIENCE = ['assistant'];
+const TOOL_INFO_RESOURCE_URI = 'internal://tool-info/{toolName}';
+function completeByPrefix(values, prefix) {
+    return values.filter((value) => value.startsWith(prefix));
+}
+function createMarkdownContent(uri, text) {
+    return { uri: uri.href, mimeType: RESOURCE_MIME_TYPE, text };
+}
+function createPatchContent(uri, text) {
+    return { uri: uri.href, mimeType: PATCH_MIME_TYPE, text };
+}
+function createResourceAnnotations(priority) {
+    return { audience: [...RESOURCE_AUDIENCE], priority };
+}
+function formatUnknownToolMessage(name) {
+    return `Unknown tool: ${name}`;
+}
+function formatDiffResourceText() {
+    const slot = getDiff();
+    if (!slot) {
+        return '# No diff cached. Call generate_diff first.';
+    }
+    return `# Diff — ${slot.mode} — ${slot.generatedAt}\n# ${slot.stats.files} file(s), +${slot.stats.added} -${slot.stats.deleted}\n\n${slot.diff}`;
+}
+export const STATIC_RESOURCES = [
+    {
+        id: 'server-instructions',
+        uri: 'internal://instructions',
+        title: 'Server Instructions',
+        description: 'Complete server usage instructions.',
+        priority: 0.8,
+    },
+    {
+        id: 'tool-catalog',
+        uri: 'internal://tool-catalog',
+        title: 'Tool Catalog',
+        description: 'Tool reference: models, params, outputs, data flow.',
+        priority: 1.0,
+        content: buildToolCatalog,
+    },
+    {
+        id: 'workflows',
+        uri: 'internal://workflows',
+        title: 'Workflow Reference',
+        description: 'Recommended workflows and tool sequences.',
+        priority: 0.9,
+        content: buildWorkflowGuide,
+    },
+    {
+        id: 'server-config',
+        uri: 'internal://server-config',
+        title: 'Server Configuration',
+        description: 'Runtime configuration and limits.',
+        priority: 0.7,
+        content: buildServerConfig,
+    },
+];
+function resolveStaticResourceContentOverride(resourceId, instructions) {
+    return resourceId === 'server-instructions' ? instructions : undefined;
+}
+function registerStaticResource(server, def, contentOverride) {
+    const content = contentOverride ?? def.content?.() ?? '';
+    server.registerResource(def.id, def.uri, {
+        title: def.title,
+        description: def.description,
+        mimeType: RESOURCE_MIME_TYPE,
+        annotations: createResourceAnnotations(def.priority),
+    }, (uri) => ({ contents: [createMarkdownContent(uri, content)] }));
+}
+function registerToolInfoResources(server) {
+    const toolNames = getToolInfoNames();
+    server.registerResource('tool-info', new ResourceTemplate(TOOL_INFO_RESOURCE_URI, {
+        list: undefined,
+        complete: {
+            toolName: (value) => completeByPrefix(toolNames, value),
+        },
+    }), {
+        title: 'Tool Info',
+        description: 'Per-tool reference: model, params, output, gotchas.',
+        mimeType: RESOURCE_MIME_TYPE,
+        annotations: createResourceAnnotations(0.6),
+    }, (uri, { toolName }) => {
+        const name = typeof toolName === 'string' ? toolName : '';
+        const info = getToolInfo(name);
+        const text = info ?? formatUnknownToolMessage(name);
+        return { contents: [createMarkdownContent(uri, text)] };
+    });
+}
+export const DIFF_RESOURCE_DESCRIPTION = 'The most recently generated diff, cached by generate_diff. Read by all review tools automatically.';
+function registerDiffResource(server) {
+    server.registerResource('diff-current', DIFF_RESOURCE_URI, {
+        title: 'Current Diff',
+        description: DIFF_RESOURCE_DESCRIPTION,
+        mimeType: PATCH_MIME_TYPE,
+        annotations: createResourceAnnotations(1.0),
+    }, (uri) => ({
+        contents: [createPatchContent(uri, formatDiffResourceText())],
+    }));
+}
+export function registerAllResources(server, instructions) {
+    for (const def of STATIC_RESOURCES) {
+        const override = resolveStaticResourceContentOverride(def.id, instructions);
+        registerStaticResource(server, def, override);
+    }
+    registerToolInfoResources(server);
+    registerDiffResource(server);
+}

package/dist/resources/instructions.d.ts

@@ -0,0 +1 @@
+export declare function buildServerInstructions(): string;

package/dist/resources/instructions.js

@@ -0,0 +1,71 @@
+import { toBulletedList, toInlineCode } from '../lib/format.js';
+import { getToolContracts } from '../lib/tools.js';
+import { PROMPT_DEFINITIONS } from '../prompts/index.js';
+import { DIFF_RESOURCE_DESCRIPTION, STATIC_RESOURCES } from './index.js';
+import { getSharedConstraints } from './tool-info.js';
+const PROMPT_LIST = PROMPT_DEFINITIONS.map((def) => `${toInlineCode(def.name)}: ${def.description}`);
+const RESOURCE_LIST = [
+    ...STATIC_RESOURCES.map((def) => `${toInlineCode(def.uri)}: ${def.description}`),
+    `${toInlineCode('internal://tool-info/{toolName}')}: Per-tool contract details.`,
+    `${toInlineCode('diff://current')}: ${DIFF_RESOURCE_DESCRIPTION}`,
+];
+function formatParameterLine(parameter) {
+    const req = parameter.required ? 'req' : 'opt';
+    return `  - \`${parameter.name}\` (${parameter.type}, ${req}): ${parameter.constraints}`;
+}
+function formatToolSection(contract) {
+    const parameterLines = contract.params.map((parameter) => formatParameterLine(parameter));
+    if (contract.model === 'none') {
+        return `### \`${contract.name}\` (Sync)
+${contract.purpose}
+- **Params**:
+${parameterLines.join('\n')}
+- **Output**: \`${contract.outputShape}\``;
+    }
+    const modelInfo = [
+        'Flash',
+        contract.thinkingLevel ? `Thinking:${contract.thinkingLevel}` : '',
+        `${Math.round(contract.timeoutMs / 1_000)}s`,
+        `MaxTokens:${contract.maxOutputTokens}`,
+    ]
+        .filter(Boolean)
+        .join(', ');
+    return `### \`${contract.name}\` (${modelInfo})
+${contract.purpose}
+- **Params**:
+${parameterLines.join('\n')}
+- **Output**: \`${contract.outputShape}\``;
+}
+export function buildServerInstructions() {
+    const contracts = getToolContracts();
+    const toolNames = contracts
+        .map((contract) => `\`${contract.name}\``)
+        .join(', ');
+    const toolSections = contracts.map((contract) => formatToolSection(contract));
+    const constraintLines = toBulletedList(getSharedConstraints());
+    return `# CODE ASSISTANT MCP
+
+## CORE
+- Domain: Gemini-powered code analysis.
+- Capabilities: tools, resources (subscribe), prompts, logging, completions, tasks.
+- Tools: ${toolNames}
+
+## PROMPTS
+${toBulletedList(PROMPT_LIST)}
+
+## RESOURCES
+${toBulletedList(RESOURCE_LIST)}
+
+## TOOLS
+${toolSections.join('\n\n')}
+
+## CONSTRAINTS
+${constraintLines}
+
+## TASK LIFECYCLE
+- Progress steps (0–6): starting → validating input → building prompt → calling model → validating response → finalizing → done.
+- Status messages update at each phase for task introspection.
+- Schema repair: on validation failure, retries with error feedback (configurable via \`GEMINI_SCHEMA_RETRIES\`).
+- Task terminal states: \`completed\` and \`failed\`; cancellations are surfaced as \`failed\` with \`error.kind=cancelled\`.
+`;
+}

package/dist/resources/server-config.d.ts

@@ -0,0 +1 @@
+export declare function buildServerConfig(): string;

package/dist/resources/server-config.js

@@ -0,0 +1,75 @@
+import { createCachedEnvInt } from '../lib/config.js';
+import { FLASH_MODEL } from '../lib/config.js';
+import { formatThinkingLevel, formatTimeoutSeconds, formatUsNumber, } from '../lib/format.js';
+import { toInlineCode } from '../lib/format.js';
+import { getToolContracts } from '../lib/tools.js';
+const DEFAULT_MAX_DIFF_CHARS = 120_000;
+const DEFAULT_MAX_CONCURRENT_CALLS = 10;
+const DEFAULT_CONCURRENT_WAIT_MS = 2_000;
+const DEFAULT_SAFETY_THRESHOLD = 'BLOCK_NONE';
+const GEMINI_HARM_BLOCK_THRESHOLD_ENV_VAR = 'GEMINI_HARM_BLOCK_THRESHOLD';
+const GEMINI_MODEL_ENV_VAR = 'GEMINI_MODEL';
+const GEMINI_BATCH_MODE_ENV_VAR = 'GEMINI_BATCH_MODE';
+const diffCharsConfig = createCachedEnvInt('MAX_DIFF_CHARS', DEFAULT_MAX_DIFF_CHARS);
+const concurrentCallsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS', DEFAULT_MAX_CONCURRENT_CALLS);
+const concurrentBatchCallsConfig = createCachedEnvInt('MAX_CONCURRENT_BATCH_CALLS', 2);
+const concurrentWaitConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS_WAIT_MS', DEFAULT_CONCURRENT_WAIT_MS);
+function getModelOverride() {
+    return process.env[GEMINI_MODEL_ENV_VAR] ?? FLASH_MODEL;
+}
+function getBatchMode() {
+    return process.env[GEMINI_BATCH_MODE_ENV_VAR] ?? 'off';
+}
+function getSafetyThreshold() {
+    return (process.env[GEMINI_HARM_BLOCK_THRESHOLD_ENV_VAR] ?? DEFAULT_SAFETY_THRESHOLD);
+}
+export function buildServerConfig() {
+    const maxDiffChars = diffCharsConfig.get();
+    const maxConcurrent = concurrentCallsConfig.get();
+    const maxConcurrentBatch = concurrentBatchCallsConfig.get();
+    const concurrentWaitMs = concurrentWaitConfig.get();
+    const defaultModel = getModelOverride();
+    const batchMode = getBatchMode();
+    const safetyThreshold = getSafetyThreshold();
+    const toolRows = getToolContracts()
+        .filter((contract) => contract.model !== 'none')
+        .map((contract) => {
+        return `| ${toInlineCode(contract.name)} | ${toInlineCode(contract.model)} | ${formatThinkingLevel(contract.thinkingLevel, '—')} | ${formatTimeoutSeconds(contract.timeoutMs)} | ${formatUsNumber(contract.maxOutputTokens)} |`;
+    })
+        .join('\n');
+    return `# Server Configuration
+
+## Input Limits
+
+| Limit | Value | Env |
+|-------|-------|-----|
+| Diff limit | ${formatUsNumber(maxDiffChars)} chars | ${toInlineCode('MAX_DIFF_CHARS')} |
+| Concurrency limit | ${maxConcurrent} | ${toInlineCode('MAX_CONCURRENT_CALLS')} |
+| Batch concurrency limit | ${maxConcurrentBatch} | ${toInlineCode('MAX_CONCURRENT_BATCH_CALLS')} |
+| Wait timeout | ${formatUsNumber(concurrentWaitMs)}ms | ${toInlineCode('MAX_CONCURRENT_CALLS_WAIT_MS')} |
+| Batch mode | ${batchMode} | ${toInlineCode('GEMINI_BATCH_MODE')} |
+
+## Model Assignments
+
+Default model: ${toInlineCode(defaultModel)} (override with ${toInlineCode('GEMINI_MODEL')})
+
+| Tool | Model | Thinking Level | Timeout | Max Output Tokens |
+|------|-------|----------------|---------|-------------------|
+${toolRows}
+
+## Safety
+
+- Harm block threshold: ${toInlineCode(safetyThreshold)}
+- Override with ${toInlineCode('GEMINI_HARM_BLOCK_THRESHOLD')} (BLOCK_NONE, BLOCK_ONLY_HIGH, BLOCK_MEDIUM_AND_ABOVE, BLOCK_LOW_AND_ABOVE)
+
+## API Keys
+
+- Set ${toInlineCode('GEMINI_API_KEY')} or ${toInlineCode('GOOGLE_API_KEY')} environment variable (required)
+
+## Batch Mode
+
+- ${toInlineCode('GEMINI_BATCH_MODE')}: ${toInlineCode('off')} (default) or ${toInlineCode('inline')}
+- ${toInlineCode('GEMINI_BATCH_POLL_INTERVAL_MS')}: poll cadence for batch status checks
+- ${toInlineCode('GEMINI_BATCH_TIMEOUT_MS')}: max wait for batch completion
+`;
+}

package/dist/resources/tool-catalog.d.ts

@@ -0,0 +1 @@
+export declare function buildToolCatalog(): string;

package/dist/resources/tool-catalog.js

@@ -0,0 +1,30 @@
+import { toInlineCode } from '../lib/format.js';
+import { buildCoreContextPack } from './tool-info.js';
+const TOOL_CATALOG_CONTENT = `# Tool Catalog Details
+
+## Optional Parameters
+
+- ${toInlineCode('language')}: Primary language hint (auto-detects). All analysis tools.
+- ${toInlineCode('testFramework')}: Framework hint. ${toInlineCode('generate_test_plan')} only.
+- ${toInlineCode('maxTestCases')}: Output cap (1–30). ${toInlineCode('generate_test_plan')} only.
+
+## Cross-Tool Data Flow
+
+\`\`\`
+analyze_pr_impact ──→ severity/categories ──→ triage decision
+                                              │
+generate_review_summary ──→ overallRisk ──────┤
+                                              ▼
+                                    diff ──→ generate_test_plan
+\`\`\`
+
+## When to Use Each Tool
+
+- **Triage**: ${toInlineCode('analyze_pr_impact')}, ${toInlineCode('generate_review_summary')}.
+- **Tests**: ${toInlineCode('generate_test_plan')}.
+- **Complexity**: ${toInlineCode('analyze_time_space_complexity')}.
+- **Breaking API**: ${toInlineCode('detect_api_breaking_changes')}.
+`;
+export function buildToolCatalog() {
+    return `${buildCoreContextPack()}\n\n${TOOL_CATALOG_CONTENT}`;
+}

package/dist/resources/tool-info.d.ts

@@ -0,0 +1,5 @@
+export declare function buildCoreContextPack(): string;
+export declare function getSharedConstraints(): readonly string[];
+export declare function getToolInfoNames(): string[];
+export declare function getToolInfo(toolName: string): string | undefined;
+export declare function getToolPurpose(toolName: string): string | undefined;

package/dist/resources/tool-info.js

@@ -0,0 +1,105 @@
+import { formatThinkingLevel, formatTimeoutSeconds, formatUsNumber, } from '../lib/format.js';
+import { toBulletedList, toInlineCode } from '../lib/format.js';
+import { getToolContract, getToolContracts } from '../lib/tools.js';
+const GLOBAL_CONSTRAINTS = [
+    'Diff budget: <= 120K chars.',
+    'Structured output: tools return both `structuredContent` and JSON text `content`.',
+];
+function formatParameterRow(entry) {
+    return `| ${entry.name} | ${entry.type} | ${entry.required ? 'Yes' : 'No'} | ${entry.constraints} | ${entry.description} |`;
+}
+function toToolInfoEntry(contract) {
+    const parameterRows = [
+        '| Param | Type | Required | Constraints | Description |',
+        '|-------|------|----------|-------------|-------------|',
+        ...contract.params.map((parameter) => formatParameterRow(parameter)),
+    ];
+    return {
+        name: contract.name,
+        purpose: contract.purpose,
+        model: contract.model,
+        thinkingLevel: formatThinkingLevel(contract.thinkingLevel),
+        timeout: formatTimeoutSeconds(contract.timeoutMs),
+        maxOutputTokens: formatUsNumber(contract.maxOutputTokens),
+        params: parameterRows.join('\n'),
+        outputShape: `\`${contract.outputShape}\``,
+        gotchas: contract.gotchas,
+        crossToolFlow: contract.crossToolFlow,
+        ...(contract.constraints
+            ? { constraints: contract.constraints }
+            : undefined),
+    };
+}
+const TOOL_INFO_ENTRIES = Object.fromEntries(getToolContracts().map((contract) => [
+    contract.name,
+    toToolInfoEntry(contract),
+]));
+const TOOL_NAMES = Object.keys(TOOL_INFO_ENTRIES).sort((a, b) => a.localeCompare(b));
+function collectToolConstraints(entries) {
+    const constraints = new Set();
+    for (const [toolName, entry] of Object.entries(entries)) {
+        for (const constraint of entry.constraints ?? []) {
+            constraints.add(`\`${toolName}\`: ${constraint}`);
+        }
+    }
+    return Array.from(constraints).sort((a, b) => a.localeCompare(b));
+}
+function formatToolInfo(entry) {
+    const constraints = [...entry.gotchas, ...entry.crossToolFlow];
+    return `# ${entry.name}
+${entry.purpose}
+
+## Model
+\`${entry.model}\` (Thinking: ${entry.thinkingLevel}, Timeout: ${entry.timeout}, Tokens: ${entry.maxOutputTokens})
+
+## Parameters
+${entry.params}
+
+## Output
+${entry.outputShape}
+
+## Constraints
+${constraints.map((item) => `- ${item}`).join('\n')}
+`;
+}
+function formatCompactToolRow(entry) {
+    return `| ${toInlineCode(entry.name)} | ${entry.model} | ${entry.timeout} | ${entry.maxOutputTokens} | ${entry.purpose} |`;
+}
+export function buildCoreContextPack() {
+    const rows = TOOL_NAMES.flatMap((toolName) => {
+        const entry = TOOL_INFO_ENTRIES[toolName];
+        return entry ? [formatCompactToolRow(entry)] : [];
+    });
+    return `# Core Context Pack
+
+## Server Essentials
+- Domain: Gemini-powered MCP server for code analysis.
+- Surface: 7 analysis tools + internal resources + guided prompts.
+- Transport: stdio with task lifecycle support.
+
+## Tool Matrix
+| Tool | Model | Timeout | Max Output Tokens | Purpose |
+|------|-------|---------|-------------------|---------|
+${rows.join('\n')}
+
+## Shared Constraints
+${toBulletedList(getSharedConstraints())}
+`;
+}
+export function getSharedConstraints() {
+    const toolConstraints = collectToolConstraints(TOOL_INFO_ENTRIES);
+    return [...GLOBAL_CONSTRAINTS, ...toolConstraints];
+}
+export function getToolInfoNames() {
+    return TOOL_NAMES;
+}
+export function getToolInfo(toolName) {
+    const entry = TOOL_INFO_ENTRIES[toolName];
+    if (!entry) {
+        return undefined;
+    }
+    return formatToolInfo(entry);
+}
+export function getToolPurpose(toolName) {
+    return getToolContract(toolName)?.purpose;
+}

package/dist/resources/workflows.d.ts

@@ -0,0 +1 @@
+export declare function buildWorkflowGuide(): string;

package/dist/resources/workflows.js

@@ -0,0 +1,59 @@
+import { toBulletedList } from '../lib/format.js';
+import { getToolContracts } from '../lib/tools.js';
+import { getSharedConstraints } from './tool-info.js';
+function buildWorkflowToolReference() {
+    const contracts = getToolContracts();
+    return contracts
+        .map((c) => `### \`${c.name}\`\n- **Purpose:** ${c.purpose}\n- **Model:** ${c.model}\n- **Output:** \`${c.outputShape}\``)
+        .join('\n\n');
+}
+export function buildWorkflowGuide() {
+    return `# Workflow Reference
+
+## A: Full PR Review
+
+1. \`generate_review_summary\` → \`{overallRisk, keyChanges[], recommendation, stats}\`
+
+## B: Impact Assessment
+
+1. \`analyze_pr_impact\` → \`{severity, categories[], breakingChanges[], rollbackComplexity}\`
+2. \`generate_review_summary\` → complementary merge recommendation
+
+> Use when categorization (breaking, api) or rollback assessment needed.
+
+## C: Test Coverage
+
+1. \`generate_test_plan\` → \`{testCases[], coverageSummary}\`
+2. Review by priority: \`must_have\` → \`should_have\` → \`nice_to_have\`
+
+> Combine with review tools.
+
+## D: Complexity & Breaking Changes
+
+1. \`analyze_time_space_complexity\` → \`{timeComplexity, spaceComplexity, isDegradation}\`
+2. \`detect_api_breaking_changes\` → \`{hasBreakingChanges, breakingChanges[]}\`
+
+> Use for algorithm or API changes. Diff-only input.
+
+## Shared Constraints
+${toBulletedList(getSharedConstraints())}
+
+## Tool Reference
+
+${buildWorkflowToolReference()}
+
+## Output Shape Reference
+
+### Finding
+\`{severity, file, line, title, explanation, recommendation}\`
+
+### Search/Replace Block
+\`{file, search, replace, explanation}\`
+
+### Test Case
+\`{name, type, file, description, pseudoCode, priority}\`
+
+### Breaking Change
+\`{element, natureOfChange, consumerImpact, suggestedMitigation}\`
+`;
+}

package/dist/schemas/inputs.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const AnalyzePrImpactInputSchema: z.ZodObject<{
+    repository: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const GenerateReviewSummaryInputSchema: z.ZodObject<{
+    repository: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const GenerateTestPlanInputSchema: z.ZodObject<{
+    repository: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
+    testFramework: z.ZodOptional<z.ZodString>;
+    maxTestCases: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const AnalyzeComplexityInputSchema: z.ZodObject<{
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const DetectApiBreakingInputSchema: z.ZodObject<{
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

package/dist/schemas/inputs.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+const INPUT_LIMITS = {
+    repository: { min: 1, max: 200 },
+    language: { min: 2, max: 32 },
+    testFramework: { min: 1, max: 50 },
+    maxTestCases: { min: 1, max: 30 },
+};
+function createBoundedString(min, max, description) {
+    return z.string().min(min).max(max).describe(description);
+}
+function createOptionalBoundedString(min, max, description) {
+    return createBoundedString(min, max, description).optional();
+}
+const LANGUAGE_DESCRIPTION = 'Primary language (e.g. TypeScript). Auto-infer from files.';
+const REPOSITORY_DESCRIPTION = 'Repo ID (owner/repo). Auto-infer from git/dir.';
+function createLanguageSchema() {
+    return createOptionalBoundedString(INPUT_LIMITS.language.min, INPUT_LIMITS.language.max, LANGUAGE_DESCRIPTION);
+}
+function createRepositorySchema() {
+    return createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, REPOSITORY_DESCRIPTION);
+}
+function createOptionalBoundedInteger(min, max, description) {
+    return z.number().int().min(min).max(max).optional().describe(description);
+}
+const RepositorySchema = createRepositorySchema();
+const LanguageSchema = createLanguageSchema();
+export const AnalyzePrImpactInputSchema = z.strictObject({
+    repository: RepositorySchema,
+    language: LanguageSchema,
+});
+export const GenerateReviewSummaryInputSchema = z.strictObject({
+    repository: RepositorySchema,
+    language: LanguageSchema,
+});
+export const GenerateTestPlanInputSchema = z.strictObject({
+    repository: RepositorySchema,
+    language: LanguageSchema,
+    testFramework: createOptionalBoundedString(INPUT_LIMITS.testFramework.min, INPUT_LIMITS.testFramework.max, 'Test framework (jest, pytest, etc). Auto-infer.'),
+    maxTestCases: createOptionalBoundedInteger(INPUT_LIMITS.maxTestCases.min, INPUT_LIMITS.maxTestCases.max, 'Max test cases (1-30). Default: 15.'),
+});
+export const AnalyzeComplexityInputSchema = z.strictObject({
+    language: LanguageSchema,
+});
+export const DetectApiBreakingInputSchema = z.strictObject({
+    language: LanguageSchema,
+});