@sdods/mcp 0.2.0

package/dist/server.d.ts

@@ -0,0 +1,29 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import type { ToolRegistry } from './registry/registry.js';
+import { type Capability, type Principal, type ToolContext, type ToolLogger } from './registry/registry.js';
+export declare const MCP_SERVER_NAME = "sdods";
+export declare const MCP_SERVER_VERSION = "0.1.0";
+export interface BuildServerOptions {
+    rootDir?: string;
+    cwd?: string;
+    project?: string;
+    env?: string;
+    caps?: Array<Capability | string> | 'all';
+    principal?: Principal;
+    registry?: ToolRegistry;
+    logger?: ToolLogger;
+    onProgress?: ToolContext['onProgress'];
+}
+export declare function stderrLogger(prefix?: string): ToolLogger;
+export declare function parseCaps(input?: Array<Capability | string> | string | 'all'): Set<Capability>;
+export declare const LOCAL_ADMIN: Principal;
+export declare function buildToolContext(opts?: BuildServerOptions): ToolContext;
+/** Build a fully wired MCP server (tools + resources + prompts) for a context. */
+export declare function buildSdodsMcpServer(opts?: BuildServerOptions): {
+    server: McpServer;
+    ctx: ToolContext;
+    registry: ToolRegistry;
+    toolCount: number;
+};
+export declare function registerPrompts(server: McpServer, ctx: ToolContext): void;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/server';
+import { cliOrNote } from './cli.js';
+import { findRepoRoot } from './cli.js';
+import { toMcpServer } from './registry/adapters.js';
+import { ALL_CAPABILITIES, DEFAULT_CAPABILITIES, } from './registry/registry.js';
+import { registerResources } from './resources.js';
+import { ROLE_PROMPTS, renderPrompt } from './prompts/index.js';
+import { createRegistry } from './tools/index.js';
+export const MCP_SERVER_NAME = 'sdods';
+export const MCP_SERVER_VERSION = '0.1.0';
+export function stderrLogger(prefix = 'sdods-mcp') {
+    const w = (level, msg, data) => {
+        if (process.env.SDODS_MCP_QUIET === '1' && level !== 'warn')
+            return;
+        process.stderr.write(`[${prefix}] ${level} ${msg}${data !== undefined ? ' ' + JSON.stringify(data) : ''}\n`);
+    };
+    return {
+        info: (m, d) => w('info', m, d),
+        warn: (m, d) => w('warn', m, d),
+        debug: (m, d) => (process.env.SDODS_DEBUG ? w('debug', m, d) : undefined),
+    };
+}
+export function parseCaps(input) {
+    if (input === 'all')
+        return new Set(ALL_CAPABILITIES);
+    const list = Array.isArray(input)
+        ? input
+        : typeof input === 'string'
+            ? input.split(',')
+            : DEFAULT_CAPABILITIES;
+    const caps = new Set();
+    for (const raw of list) {
+        const c = String(raw).trim();
+        if (c === 'all')
+            return new Set(ALL_CAPABILITIES);
+        if (!c)
+            continue;
+        if (!ALL_CAPABILITIES.includes(c))
+            throw new Error(`Unknown capability "${c}". Known: ${ALL_CAPABILITIES.join(', ')}`);
+        caps.add(c);
+    }
+    return caps;
+}
+export const LOCAL_ADMIN = { name: 'local', scopes: ['*'], via: 'stdio' };
+export function buildToolContext(opts = {}) {
+    const rootDir = opts.rootDir ?? findRepoRoot(opts.cwd ?? process.cwd());
+    const principal = opts.principal ?? LOCAL_ADMIN;
+    return {
+        rootDir,
+        cwd: opts.cwd ?? rootDir,
+        principal: principal.scopes.includes('*') ? { ...principal, scopes: allScopes() } : principal,
+        caps: parseCaps(opts.caps),
+        project: opts.project,
+        env: opts.env,
+        onProgress: opts.onProgress,
+        logger: opts.logger ?? stderrLogger(),
+    };
+}
+function allScopes() {
+    // lazy import to avoid a static dependency on the scope list shape
+    return [
+        'orgs:read',
+        'orgs:admin',
+        'workspaces:read',
+        'workspaces:write',
+        'projects:read',
+        'projects:write',
+        'envs:read',
+        'envs:write',
+        'datasets:read',
+        'datasets:write',
+        'runs:read',
+        'runs:write',
+        'runs:ingest',
+        'artifacts:read',
+        'features:read',
+        'features:write',
+        'agents:run',
+        'agents:review',
+        'integrations:read',
+        'integrations:write',
+        'schedules:read',
+        'schedules:write',
+        'processes:read',
+        'processes:write',
+        'users:admin',
+        'audit:read',
+    ];
+}
+/** Build a fully wired MCP server (tools + resources + prompts) for a context. */
+export function buildSdodsMcpServer(opts = {}) {
+    const ctx = buildToolContext(opts);
+    const registry = opts.registry ?? createRegistry();
+    const server = new McpServer({ name: MCP_SERVER_NAME, version: MCP_SERVER_VERSION }, {
+        capabilities: { tools: {}, resources: {}, prompts: {}, logging: {} },
+        instructions: 'SDODS is an automation and orchestration platform with a reusable architecture. Tools are grouped by prefix: project_*, workspace_*, process_*, feature_*, step_*, run_*, heal_*, data_*, analyze_*, issue_*, schedule_*, proposal_*. Write tools only create proposals; nothing touches the working tree until a person accepts. Start with project_list, then feature_list / step_list before writing scenarios.',
+    });
+    const toolCount = toMcpServer(registry, server, ctx);
+    registerResources(server, ctx);
+    registerPrompts(server, ctx);
+    return { server, ctx, registry, toolCount };
+}
+export function registerPrompts(server, ctx) {
+    for (const role of Object.keys(ROLE_PROMPTS)) {
+        const p = ROLE_PROMPTS[role];
+        server.registerPrompt(`sdods-${role === 'planner' ? 'plan' : role === 'generator' ? 'generate' : role === 'healer' ? 'heal' : role === 'upgrader' ? 'upgrade' : 'review'}`, {
+            title: p.title,
+            description: p.description,
+            argsSchema: z.object({
+                project: z.string().optional().describe('project slug'),
+                env: z.string().optional(),
+                goal: z.string().optional().describe('what to plan/generate/heal/upgrade/review'),
+            }),
+        }, async (args) => {
+            const project = args.project ?? ctx.project;
+            let steps;
+            if (project) {
+                const data = await cliOrNote(['steps', 'list', '-p', project], { cwd: ctx.rootDir, timeoutMs: 120_000 }).catch(() => undefined);
+                if (Array.isArray(data))
+                    steps = data.map((s) => `${s.keyword ?? ''} ${s.pattern ?? ''}`.trim());
+            }
+            return {
+                description: p.description,
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: renderPrompt(role, {
+                                project,
+                                env: args.env ?? ctx.env,
+                                goal: args.goal,
+                                steps,
+                            }),
+                        },
+                    },
+                ],
+            };
+        });
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/tools/analyze.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+export interface Evidence {
+    finding: string;
+    confidence: number;
+    evidence: string[];
+}
+export declare function analyzeApp(appPath: string): Record<string, unknown>;
+export declare function analyzeCoverage(root: string): {
+    routes: {
+        route: string;
+        path: string;
+        scenarios: number;
+        viaPageObject: boolean;
+        suites: string[];
+    }[];
+    endpoints: {
+        scenarios: number;
+        suites: string[];
+        module: string;
+        endpoint: string;
+    }[];
+    modules: {
+        module: string;
+        features: number;
+        scenarios: number;
+    }[];
+    uncoveredRoutes: string[];
+    totals: {
+        features: number;
+        scenarios: number;
+    };
+};
+export declare function analyzeBestPractices(root: string): {
+    findings: {
+        severity: "error" | "warning" | "info";
+        rule: string;
+        file: string;
+        line?: number;
+        message: string;
+        fix?: string;
+    }[];
+    stats: {
+        features: number;
+        errors: number;
+        warnings: number;
+    };
+    frequentSteps: {
+        text: string;
+        uses: number;
+    }[];
+};
+export declare function analyzeLocators(root: string): {
+    byKind: Record<string, number>;
+    total: number;
+    fragile: {
+        file: string;
+        line: number;
+        kind: string;
+        snippet: string;
+        healed: boolean;
+    }[];
+    score: number;
+};
+export declare function analyzeChangeImpact(root: string, rootDir: string, range: string): {
+    range: string;
+    changedFiles: string[];
+    impacted: {
+        feature: string;
+        reasons: string[];
+    }[];
+    suggestion: string;
+};
+export declare const analyzeTools: (import("../registry/registry.js").SdodsTool<{
+    path: z.ZodString;
+}> | import("../registry/registry.js").SdodsTool<{
+    project: z.ZodString;
+}> | import("../registry/registry.js").SdodsTool<{
+    project: z.ZodString;
+    range: z.ZodDefault<z.ZodString>;
+}> | import("../registry/registry.js").SdodsTool<{
+    runId: z.ZodString;
+    fingerprint: z.ZodString;
+}> | import("../registry/registry.js").SdodsTool<{
+    project: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}>)[];
+//# sourceMappingURL=analyze.d.ts.map