@sdods/mcp 0.2.0

package/dist/tools/issue-schedule.js

@@ -0,0 +1,193 @@
+import { join } from 'node:path';
+import { z } from 'zod';
+import { SdodsCliError, sdodsCli, cliOrNote } from '../cli.js';
+import { projectRoot, readYaml } from '../fs.js';
+import { defineTool, summarize } from '../registry/registry.js';
+export const issueTools = [
+    defineTool({
+        name: 'issue_create',
+        title: 'Create an issue for a failed run',
+        description: 'Create (or comment on an existing) GitHub/Jira issue for the failures of a run via `sdods integrations notify`. Use dryRun to preview.',
+        shape: {
+            runId: z.string(),
+            project: z.string().optional(),
+            provider: z.enum(['github', 'jira']).optional(),
+            dryRun: z.boolean().optional(),
+        },
+        access: 'write',
+        domain: 'integrations',
+        capability: 'issues',
+        annotations: { openWorldHint: true },
+        handler: async (args, ctx) => {
+            const cli = ['integrations', 'notify', '--run-id', args.runId, '--from-files'];
+            if (args.project)
+                cli.push('-p', args.project);
+            if (args.provider)
+                cli.push('--provider', args.provider);
+            if (args.dryRun)
+                cli.push('--dry-run');
+            const data = await cliOrNote(cli, {
+                cwd: ctx.rootDir,
+                signal: ctx.signal,
+                timeoutMs: 120_000,
+            });
+            return {
+                text: summarize(`Issue ${args.dryRun ? 'preview' : 'creation'} for run ${args.runId}`, data),
+                data,
+            };
+        },
+    }),
+    defineTool({
+        name: 'issue_link',
+        title: 'List issue links',
+        description: 'Scenario ↔ issue links (@jira:KEY / @github:N tags and auto-created issues) for a project.',
+        shape: { project: z.string() },
+        access: 'read',
+        domain: 'integrations',
+        capability: 'issues',
+        handler: async (args, ctx) => {
+            const data = await cliOrNote(['integrations', 'links', '-p', args.project], {
+                cwd: ctx.rootDir,
+                signal: ctx.signal,
+            });
+            return { text: summarize(`Issue links for ${args.project}`, data), data };
+        },
+    }),
+    defineTool({
+        name: 'issue_sync',
+        title: 'Sync issue statuses',
+        description: 'Scan features for @jira:/@github: tags, create missing links and refresh statuses from the trackers.',
+        shape: { project: z.string() },
+        access: 'write',
+        domain: 'integrations',
+        capability: 'issues',
+        annotations: { openWorldHint: true },
+        handler: async (args, ctx) => {
+            try {
+                const r = await sdodsCli(['integrations', 'sync', '-p', args.project], {
+                    cwd: ctx.rootDir,
+                    signal: ctx.signal,
+                    timeoutMs: 120_000,
+                });
+                return { text: summarize(`Synced ${args.project}`, r.json), data: r.json };
+            }
+            catch (e) {
+                if (e instanceof SdodsCliError)
+                    return { text: `Sync failed: ${e.message}`, data: e.error, isError: true };
+                throw e;
+            }
+        },
+    }),
+];
+export const scheduleTools = [
+    defineTool({
+        name: 'schedule_list',
+        title: 'List schedules',
+        description: 'Cron schedules declared in a project yaml (and the processes that carry a schedule).',
+        shape: { project: z.string() },
+        access: 'read',
+        domain: 'schedules',
+        capability: 'schedules',
+        handler: async (args, ctx) => {
+            const root = projectRoot(ctx.rootDir, args.project);
+            const yaml = readYaml(join(root, 'sdods.project.yaml'));
+            const ws = readYaml(join(ctx.rootDir, 'sdods.workspace.yaml'));
+            const scheduledProcesses = [...(ws?.defaults?.processes ?? []), ...(yaml?.processes ?? [])]
+                .filter((p) => p.schedule)
+                .map((p) => ({ process: p.name, cron: p.schedule, trigger: p.trigger }));
+            const data = { schedules: yaml?.schedules ?? [], scheduledProcesses };
+            return { text: summarize(`Schedules of ${args.project}`, data), data };
+        },
+    }),
+    defineTool({
+        name: 'schedule_next',
+        title: 'Next fire times',
+        description: 'Preview the next fire times of a cron expression in a timezone (5-field cron).',
+        shape: {
+            cron: z.string(),
+            timezone: z.string().optional(),
+            count: z.number().int().positive().max(20).optional(),
+        },
+        access: 'read',
+        domain: 'schedules',
+        capability: 'schedules',
+        handler: async (args) => {
+            const times = nextCronTimes(args.cron, args.count ?? 5, args.timezone ?? 'UTC');
+            return {
+                text: summarize(`Next ${times.length} fire times for "${args.cron}" (${args.timezone ?? 'UTC'})`, times),
+                data: { times },
+            };
+        },
+    }),
+];
+/** Minimal 5-field cron evaluator (minute hour dom month dow) — good enough for previews. */
+export function nextCronTimes(expr, count, timeZone, from = new Date()) {
+    const fields = expr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        throw Object.assign(new Error(`Expected 5 cron fields, got ${fields.length}`), {
+            error: { code: 'INVALID_ARGS' },
+        });
+    const parse = (f, min, max) => {
+        const out = new Set();
+        for (const part of f.split(',')) {
+            const [rangePart, stepPart] = part.split('/');
+            const step = stepPart ? Number(stepPart) : 1;
+            let lo = min;
+            let hi = max;
+            if (rangePart !== '*') {
+                const [a, b] = rangePart.split('-').map(Number);
+                lo = a;
+                hi = b ?? (stepPart ? max : a);
+            }
+            for (let v = lo; v <= hi; v += step)
+                out.add(v);
+        }
+        return out;
+    };
+    const [mi, ho, dom, mo, dow] = [
+        parse(fields[0], 0, 59),
+        parse(fields[1], 0, 23),
+        parse(fields[2], 1, 31),
+        parse(fields[3], 1, 12),
+        parse(fields[4], 0, 7),
+    ];
+    if (dow.has(7))
+        dow.add(0);
+    const fmt = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        hourCycle: 'h23',
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric',
+        weekday: 'short',
+    });
+    const parts = (d) => {
+        const p = Object.fromEntries(fmt.formatToParts(d).map((x) => [x.type, x.value]));
+        const wd = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(p.weekday);
+        return {
+            minute: Number(p.minute),
+            hour: Number(p.hour),
+            day: Number(p.day),
+            month: Number(p.month),
+            weekday: wd,
+        };
+    };
+    const out = [];
+    const cursor = new Date(from);
+    cursor.setUTCSeconds(0, 0);
+    cursor.setUTCMinutes(cursor.getUTCMinutes() + 1);
+    for (let i = 0; i < 366 * 24 * 60 && out.length < count; i++) {
+        const p = parts(cursor);
+        if (mi.has(p.minute) &&
+            ho.has(p.hour) &&
+            dom.has(p.day) &&
+            mo.has(p.month) &&
+            dow.has(p.weekday))
+            out.push(cursor.toISOString());
+        cursor.setUTCMinutes(cursor.getUTCMinutes() + 1);
+    }
+    return out;
+}
+//# sourceMappingURL=issue-schedule.js.map

package/dist/tools/project.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const projectTools: (import("../registry/registry.js").SdodsTool<{}> | import("../registry/registry.js").SdodsTool<{
+    project: z.ZodString;
+    env: z.ZodOptional<z.ZodString>;
+    explain: z.ZodOptional<z.ZodBoolean>;
+}> | import("../registry/registry.js").SdodsTool<{
+    project: z.ZodString;
+}> | import("../registry/registry.js").SdodsTool<{
+    project: z.ZodOptional<z.ZodString>;
+}>)[];
+//# sourceMappingURL=project.d.ts.map

package/dist/tools/project.js

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import { sdodsCli, cliOrNote } from '../cli.js';
+import { defineTool, summarize } from '../registry/registry.js';
+export const projectTools = [
+    defineTool({
+        name: 'project_list',
+        title: 'List projects',
+        description: 'List SDODS projects discovered under projects/ with layers, browsers and environments.',
+        shape: {},
+        access: 'read',
+        domain: 'projects',
+        capability: 'core',
+        docsPath: '/docs/reference/mcp-tools',
+        handler: async (_args, ctx) => {
+            const r = await sdodsCli(['project', 'list'], {
+                cwd: ctx.rootDir,
+                signal: ctx.signal,
+            });
+            return { text: summarize('Projects', r.json), data: r.json };
+        },
+    }),
+    defineTool({
+        name: 'project_get_config',
+        title: 'Get resolved project config',
+        description: 'Resolved configuration for a project and environment (defaults → project yaml → env yaml → .env → process → CLI). Secrets are redacted. Use explain=true to see which layer produced each key.',
+        shape: {
+            project: z.string().describe('project slug'),
+            env: z.string().optional().describe('environment name (default: project envs.default)'),
+            explain: z.boolean().optional().describe('return provenance rows instead of the tree'),
+        },
+        access: 'read',
+        domain: 'projects',
+        capability: 'core',
+        handler: async (args, ctx) => {
+            const cli = ['config', 'show', '-p', args.project];
+            if (args.env)
+                cli.push('-e', args.env);
+            if (args.explain)
+                cli.push('--explain');
+            const r = await sdodsCli(cli, { cwd: ctx.rootDir, signal: ctx.signal });
+            return {
+                text: summarize(`Config for ${args.project}${args.env ? ` (${args.env})` : ''}`, r.json),
+                data: r.json,
+            };
+        },
+    }),
+    defineTool({
+        name: 'project_list_envs',
+        title: 'List environments',
+        description: 'Environments of a project with UI/API base URLs and whether they resolve without errors.',
+        shape: { project: z.string() },
+        access: 'read',
+        domain: 'envs',
+        capability: 'core',
+        handler: async (args, ctx) => {
+            const r = await sdodsCli(['env', 'list', '-p', args.project], {
+                cwd: ctx.rootDir,
+                signal: ctx.signal,
+            });
+            return { text: summarize(`Environments of ${args.project}`, r.json), data: r.json };
+        },
+    }),
+    defineTool({
+        name: 'project_validate_config',
+        title: 'Validate all configs',
+        description: 'Validate every project and environment yaml without running anything.',
+        shape: {},
+        access: 'read',
+        domain: 'projects',
+        capability: 'core',
+        handler: async (_args, ctx) => {
+            let data;
+            try {
+                data = (await sdodsCli(['config', 'validate'], { cwd: ctx.rootDir, signal: ctx.signal }))
+                    .json;
+            }
+            catch (e) {
+                // exit code 2 still prints the table as JSON
+                const err = e;
+                return {
+                    text: `Validation reported problems: ${err.message}`,
+                    data: { error: err.message },
+                    isError: true,
+                };
+            }
+            return { text: summarize('Configuration validation', data), data };
+        },
+    }),
+    defineTool({
+        name: 'project_doctor',
+        title: 'Doctor',
+        description: 'Check Node, Bun, browser engines, projects, env vars and database settings.',
+        shape: { project: z.string().optional() },
+        access: 'read',
+        domain: 'projects',
+        capability: 'core',
+        annotations: { openWorldHint: true },
+        handler: async (args, ctx) => {
+            const cli = ['doctor', ...(args.project ? ['-p', args.project] : [])];
+            let data;
+            try {
+                data = (await sdodsCli(cli, { cwd: ctx.rootDir, signal: ctx.signal, timeoutMs: 60_000 }))
+                    .json;
+            }
+            catch (e) {
+                const err = e;
+                // doctor exits 1 when a check fails but still prints JSON on stdout
+                const m = /\[[\s\S]*\]/.exec(err.stderr ?? '');
+                data = m ? JSON.parse(m[0]) : { error: err.message };
+            }
+            return { text: summarize('Doctor', data), data };
+        },
+    }),
+    defineTool({
+        name: 'workspace_tree',
+        title: 'Workspace tree',
+        description: 'Hierarchy: organization → workspaces → projects → modules (testing types, tags) → processes.',
+        shape: {},
+        access: 'read',
+        domain: 'workspaces',
+        capability: 'core',
+        handler: async (_args, ctx) => {
+            const data = await cliOrNote(['workspace', 'tree'], { cwd: ctx.rootDir, signal: ctx.signal });
+            return { text: summarize('Workspace tree', data), data };
+        },
+    }),
+    defineTool({
+        name: 'process_list',
+        title: 'List processes',
+        description: 'Named run recipes (pr-check, nightly-regression, release-gate …) visible to a project: trigger, tags, layers, browsers, gates.',
+        shape: { project: z.string() },
+        access: 'read',
+        domain: 'processes',
+        capability: 'core',
+        handler: async (args, ctx) => {
+            const data = await cliOrNote(['processes', 'list', '-p', args.project], {
+                cwd: ctx.rootDir,
+                signal: ctx.signal,
+            });
+            return { text: summarize(`Processes for ${args.project}`, data), data };
+        },
+    }),
+];
+//# sourceMappingURL=project.js.map

package/dist/tools/proposal.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const proposalTools: (import("../registry/registry.js").SdodsTool<{
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        accepted: "accepted";
+        rejected: "rejected";
+    }>>;
+    project: z.ZodOptional<z.ZodString>;
+}> | import("../registry/registry.js").SdodsTool<{
+    id: z.ZodString;
+    includeDiff: z.ZodOptional<z.ZodBoolean>;
+}> | import("../registry/registry.js").SdodsTool<{
+    id: z.ZodString;
+    reviewedBy: z.ZodOptional<z.ZodString>;
+}> | import("../registry/registry.js").SdodsTool<{
+    id: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}>)[];
+//# sourceMappingURL=proposal.d.ts.map

package/dist/tools/proposal.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { ProposalStore } from '../proposals.js';
+import { defineTool, summarize } from '../registry/registry.js';
+export const proposalTools = [
+    defineTool({
+        name: 'proposal_list',
+        title: 'List proposals',
+        description: 'Pending/accepted/rejected proposals written by agents and write tools.',
+        shape: {
+            status: z.enum(['pending', 'accepted', 'rejected']).optional(),
+            project: z.string().optional(),
+        },
+        access: 'read',
+        domain: 'features',
+        capability: 'core',
+        handler: async (args, ctx) => {
+            const rows = new ProposalStore(ctx.rootDir).list(args).map((m) => ({
+                id: m.id,
+                role: m.role,
+                project: m.project,
+                status: m.status,
+                summary: m.summary,
+                files: m.files.length,
+                createdAt: m.createdAt,
+                costUsd: m.costUsd,
+            }));
+            return { text: summarize(`Proposals (${rows.length})`, rows), data: rows };
+        },
+    }),
+    defineTool({
+        name: 'proposal_get',
+        title: 'Get proposal',
+        description: 'Manifest, files and a diff against the working tree for one proposal.',
+        shape: { id: z.string(), includeDiff: z.boolean().optional() },
+        access: 'read',
+        domain: 'features',
+        capability: 'core',
+        handler: async (args, ctx) => {
+            const store = new ProposalStore(ctx.rootDir);
+            const m = store.get(args.id);
+            if (!m)
+                throw Object.assign(new Error(`Unknown proposal ${args.id}`), {
+                    error: { code: 'NOT_FOUND' },
+                });
+            const files = m.files.map((f) => ({
+                ...f,
+                content: f.op === 'delete' ? undefined : store.readFile(args.id, f),
+            }));
+            const diff = args.includeDiff === false ? undefined : store.diff(args.id);
+            return {
+                text: `${m.summary}\n\n${diff ? `\`\`\`diff\n${diff.slice(0, 6000)}\n\`\`\`` : ''}`,
+                data: { ...m, files, diff },
+            };
+        },
+    }),
+    defineTool({
+        name: 'proposal_accept',
+        title: 'Accept proposal',
+        description: 'Apply a proposal to the working tree (a person should have reviewed the diff first).',
+        shape: { id: z.string(), reviewedBy: z.string().optional() },
+        access: 'write',
+        domain: 'agents',
+        capability: 'agents',
+        annotations: { destructiveHint: true },
+        handler: async (args, ctx) => {
+            const written = new ProposalStore(ctx.rootDir).accept(args.id, {
+                reviewedBy: args.reviewedBy ?? ctx.principal.name,
+            });
+            return {
+                text: `Applied ${written.length} file(s):\n${written.map((w) => `- ${w}`).join('\n')}\nRun feature_lint next.`,
+                data: { id: args.id, written },
+            };
+        },
+    }),
+    defineTool({
+        name: 'proposal_reject',
+        title: 'Reject proposal',
+        description: 'Mark a proposal rejected with an optional reason.',
+        shape: { id: z.string(), reason: z.string().optional() },
+        access: 'write',
+        domain: 'agents',
+        capability: 'agents',
+        handler: async (args, ctx) => {
+            const m = new ProposalStore(ctx.rootDir).reject(args.id, args.reason, ctx.principal.name);
+            return { text: `Rejected ${m.id}.`, data: m };
+        },
+    }),
+];
+//# sourceMappingURL=proposal.js.map

package/dist/tools/run.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+export declare const runTools: (import("../registry/registry.js").SdodsTool<{
+    project: z.ZodString;
+    env: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodString>;
+    layers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        api: "api";
+        ui: "ui";
+        hybrid: "hybrid";
+        recorded: "recorded";
+    }>>>;
+    browsers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        chromium: "chromium";
+        firefox: "firefox";
+        webkit: "webkit";
+        "mobile-chrome": "mobile-chrome";
+        "mobile-safari": "mobile-safari";
+    }>>>;
+    process: z.ZodOptional<z.ZodString>;
+    modules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    harMode: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        update: "update";
+        replay: "replay";
+    }>>;
+    workers: z.ZodOptional<z.ZodNumber>;
+    retries: z.ZodOptional<z.ZodNumber>;
+    grep: z.ZodOptional<z.ZodString>;
+    headed: z.ZodOptional<z.ZodBoolean>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+    runId: z.ZodOptional<z.ZodString>;
+}> | import("../registry/registry.js").SdodsTool<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    project: z.ZodOptional<z.ZodString>;
+}> | import("../registry/registry.js").SdodsTool<{
+    runId: z.ZodString;
+}> | import("../registry/registry.js").SdodsTool<{
+    runId: z.ZodString;
+    fingerprint: z.ZodString;
+    retry: z.ZodOptional<z.ZodNumber>;
+}> | import("../registry/registry.js").SdodsTool<{
+    runId: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+}> | import("../registry/registry.js").SdodsTool<{
+    project: z.ZodOptional<z.ZodString>;
+    runs: z.ZodOptional<z.ZodNumber>;
+}>)[];
+export declare function readRunLog(dir: string): string | undefined;
+//# sourceMappingURL=run.d.ts.map