@debugg-ai/debugg-ai-mcp 2.9.3 → 3.0.0

package/dist/tools/testSuite.js

@@ -0,0 +1,50 @@
+import { TestSuiteInputSchema } from '../types/index.js';
+import { testSuiteHandler } from '../handlers/testSuiteHandler.js';
+const DESCRIPTION = `Manage and run test suites. Identify a suite by suiteUuid, or suiteName + a project identifier (projectUuid|projectName). Pass an "action":
+  - "list"    {projectUuid|projectName, search?, page?, pageSize?} → paginated suites with status/pass-rate.
+  - "create"  {name, description, projectUuid|projectName} → create a suite.
+  - "run"     {suiteUuid|(suiteName+project), targetUrl?} → run all tests async. Poll with action:"results".
+  - "results" {suiteUuid|(suiteName+project)} → suite + per-test outcomes.
+  - "delete"  {suiteUuid|(suiteName+project), confirm?} → soft-delete (DESTRUCTIVE; requires confirmation).`;
+const PROJECT_PROPS = {
+    projectUuid: { type: 'string', description: 'Project UUID (or projectName).' },
+    projectName: { type: 'string', description: 'Project name (or projectUuid).' },
+};
+const SUITE_PROPS = {
+    suiteUuid: { type: 'string', description: 'Test suite UUID.' },
+    suiteName: { type: 'string', description: 'Test suite name (requires a project identifier).' },
+};
+export function buildTestSuiteTool() {
+    return {
+        name: 'test_suite',
+        title: 'Test Suite',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: ['list', 'create', 'run', 'results', 'delete'], description: 'Operation to perform.' },
+                ...SUITE_PROPS,
+                ...PROJECT_PROPS,
+                name: { type: 'string', description: '[create] Suite name.' },
+                description: { type: 'string', description: '[create] Suite description.' },
+                search: { type: 'string', description: '[list] Text filter over name/description.' },
+                page: { type: 'number', description: '[list] Page (1-indexed).' },
+                pageSize: { type: 'number', description: '[list] Page size (1..100).' },
+                targetUrl: { type: 'string', description: '[run] Override the default test target (full URL).' },
+                confirm: { type: 'boolean', description: '[delete] Set true to confirm deletion (when the client cannot prompt).' },
+            },
+            required: ['action'],
+            oneOf: [
+                { properties: { action: { const: 'list' } }, required: ['action'] },
+                { properties: { action: { const: 'create' } }, required: ['action', 'name', 'description'] },
+                { properties: { action: { const: 'run' } }, required: ['action'] },
+                { properties: { action: { const: 'results' } }, required: ['action'] },
+                { properties: { action: { const: 'delete' } }, required: ['action'] },
+            ],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedTestSuiteTool() {
+    return { ...buildTestSuiteTool(), inputSchema: TestSuiteInputSchema, handler: testSuiteHandler };
+}

package/dist/tools/triggerCrawl.js

@@ -71,10 +71,6 @@ export function buildTriggerCrawlTool(ctx) {
                     type: 'string',
                     description: 'The real password for the username above. Do NOT guess.',
                 },
-                headless: {
-                    type: 'boolean',
-                    description: 'Run the browser in headless mode. Defaults to backend configuration.',
-                },
                 timeoutSeconds: {
                     type: 'number',
                     description: 'Maximum wall-time the crawl may run, in seconds (1..1800). Backend enforces this per workflow execution.',

package/dist/types/index.js

@@ -25,7 +25,7 @@ export const TriggerCrawlInputSchema = z.object({
     credentialRole: z.string().optional(),
     username: z.string().optional(),
     password: z.string().optional(),
-    headless: z.boolean().optional(),
+    // headless is intentionally NOT accepted — the MCP always runs headless (D7).
     timeoutSeconds: z.number().int().positive().max(1800, 'timeoutSeconds cannot exceed 1800 (30 min)').optional(),
     repoName: z.string().optional(),
 }).strict();
@@ -220,3 +220,57 @@ export const GetTestSuiteResultsInputSchema = z.object({
     ...suiteIdentifier,
     ...projectIdentifier,
 }).strict();
+// ── Consolidated action-based tool schemas (epic yg7o6: 20 → 8 tools) ─────────
+// Each entity tool takes a required `action` discriminator; params validate
+// per-action. Delete branches carry an optional `confirm` (guarded by D2).
+const _page = z.number().int().min(1).optional();
+const _pageSize = z.number().int().min(1).optional();
+export const ProjectInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('get'), uuid: z.string().uuid() }).strict(),
+    z.object({ action: z.literal('list'), q: z.string().min(1).optional(), page: _page, pageSize: _pageSize }).strict(),
+    z.object({
+        action: z.literal('create'),
+        name: z.string().min(1),
+        platform: z.string().min(1),
+        teamUuid: z.string().uuid().optional(),
+        teamName: z.string().min(1).optional(),
+        repoUuid: z.string().uuid().optional(),
+        repoName: z.string().min(1).optional(),
+    }).strict(),
+]).superRefine((v, ctx) => {
+    if (v.action === 'create') {
+        if (v.teamUuid && v.teamName)
+            ctx.addIssue({ code: 'custom', message: 'Provide teamUuid OR teamName, not both.' });
+        if (v.repoUuid && v.repoName)
+            ctx.addIssue({ code: 'custom', message: 'Provide repoUuid OR repoName, not both.' });
+        if (!v.teamUuid && !v.teamName)
+            ctx.addIssue({ code: 'custom', message: 'Must provide teamUuid or teamName.' });
+        if (!v.repoUuid && !v.repoName)
+            ctx.addIssue({ code: 'custom', message: 'Must provide repoUuid or repoName.' });
+    }
+});
+export const EnvironmentInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('get'), uuid: z.string().uuid(), projectUuid: z.string().uuid().optional() }).strict(),
+    z.object({ action: z.literal('list'), projectUuid: z.string().uuid().optional(), q: z.string().min(1).optional(), page: _page, pageSize: _pageSize }).strict(),
+    z.object({ action: z.literal('create'), name: z.string().min(1), url: z.string().url('url is required for standard environments'), description: z.string().optional(), projectUuid: z.string().uuid().optional(), credentials: z.array(CredentialSeedSchema).optional() }).strict(),
+    z.object({ action: z.literal('update'), uuid: z.string().uuid(), name: z.string().min(1).optional(), url: z.string().url().optional(), description: z.string().optional(), projectUuid: z.string().uuid().optional(), addCredentials: z.array(CredentialSeedSchema).optional(), updateCredentials: z.array(CredentialUpdateSchema).optional(), removeCredentialIds: z.array(z.string().uuid()).optional() }).strict(),
+    z.object({ action: z.literal('delete'), uuid: z.string().uuid(), projectUuid: z.string().uuid().optional(), confirm: z.boolean().optional() }).strict(),
+]);
+export const TestSuiteInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('list'), ...projectIdentifier, search: z.string().optional(), page: _page, pageSize: z.number().int().min(1).max(100).optional() }).strict(),
+    z.object({ action: z.literal('create'), name: z.string().min(1), description: z.string().min(1), ...projectIdentifier }).strict(),
+    z.object({ action: z.literal('run'), ...suiteIdentifier, ...projectIdentifier, targetUrl: z.string().url().optional() }).strict(),
+    z.object({ action: z.literal('results'), ...suiteIdentifier, ...projectIdentifier }).strict(),
+    z.object({ action: z.literal('delete'), ...suiteIdentifier, ...projectIdentifier, confirm: z.boolean().optional() }).strict(),
+]);
+export const TestCaseInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('create'), name: z.string().min(1), description: z.string().min(1), agentTaskDescription: z.string().min(1), ...suiteIdentifier, ...projectIdentifier, relativeUrl: z.string().regex(/^\//, 'Must start with /').optional(), maxSteps: z.number().int().min(1).max(100).optional() }).strict(),
+    z.object({ action: z.literal('update'), testUuid: z.string().uuid(), name: z.string().min(1).optional(), description: z.string().min(1).optional(), agentTaskDescription: z.string().min(1).optional() }).strict(),
+    z.object({ action: z.literal('delete'), testUuid: z.string().uuid(), confirm: z.boolean().optional() }).strict(),
+]);
+// NOTE: D6 (recency sort) deferred — the backend listExecutions has no ordering
+// param; threading real sort needs a backend change. Tracked, not shipped here.
+export const ExecutionsInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('get'), uuid: z.string().uuid() }).strict(),
+    z.object({ action: z.literal('list'), projectUuid: z.string().uuid().optional(), status: z.string().min(1).optional(), page: _page, pageSize: _pageSize }).strict(),
+]);

package/dist/utils/confirmDestructive.js

@@ -0,0 +1,48 @@
+/**
+ * Destructive-action guard (epic debugg_ai_mcp-yg7o6, decision D2).
+ *
+ * Consolidated entity tools expose a `delete` action. Before any delete runs we
+ * require confirmation:
+ *   - If the client supports elicitation (ctx.elicit present), prompt for it.
+ *   - Otherwise fall back to a required `confirm: true` argument.
+ *
+ * This keeps deletes safe on EVERY client without depending on the elicitation
+ * epic — that epic only has to populate `ctx.elicit`; the confirm-arg path here
+ * ships standalone.
+ */
+/** Action names treated as destructive. Currently just `delete`. */
+export const DESTRUCTIVE_ACTIONS = new Set(['delete']);
+export function isDestructiveAction(action) {
+    return DESTRUCTIVE_ACTIONS.has(action);
+}
+function refusal(error, message) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ error, message }, null, 2) }],
+        isError: true,
+    };
+}
+/**
+ * Gate a destructive action.
+ *
+ * @returns `null` to proceed, or a `ToolResponse` (isError) to abort the call.
+ */
+export async function ensureConfirmed(action, label, input, ctx) {
+    if (!isDestructiveAction(action))
+        return null;
+    if (ctx.elicit) {
+        const res = await ctx.elicit({
+            message: `Delete ${label}? This cannot be undone.`,
+            requestedSchema: {
+                type: 'object',
+                properties: { confirm: { type: 'boolean', description: 'Confirm deletion of ' + label } },
+                required: ['confirm'],
+            },
+        });
+        if (res.action === 'accept' && res.content?.confirm === true)
+            return null;
+        return refusal('confirmation_declined', `Deletion of ${label} was not confirmed.`);
+    }
+    if (input.confirm === true)
+        return null;
+    return refusal('confirmation_required', `Refusing to delete ${label} without confirmation. Pass confirm:true, or use an elicitation-capable client.`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "2.9.3",
+  "version": "3.0.0",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "bin": {
@@ -48,6 +48,10 @@
   ],
   "author": "Quinn Osha",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/debugg-ai/debugg-ai-mcp.git"
+  },
   "homepage": "https://debugg.ai",
   "bugs": "https://github.com/debugg-ai/debugg-ai-mcp/issues",
   "changelog": "https://github.com/debugg-ai/debugg-ai-mcp/CHANGELOG.md",

package/dist/handlers/deleteProjectHandler.js

@@ -1,39 +0,0 @@
-import { Logger } from '../utils/logger.js';
-import { handleExternalServiceError } from '../utils/errors.js';
-import { DebuggAIServerClient } from '../services/index.js';
-import { config } from '../config/index.js';
-const logger = new Logger({ module: 'deleteProjectHandler' });
-function notFound(uuid) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify({
-                    error: 'NotFound',
-                    message: `Project ${uuid} not found.`,
-                    uuid,
-                }, null, 2) }],
-        isError: true,
-    };
-}
-export async function deleteProjectHandler(input, _context) {
-    const start = Date.now();
-    logger.toolStart('delete_project', { uuid: input.uuid });
-    try {
-        const client = new DebuggAIServerClient(config.api.key);
-        await client.init();
-        try {
-            await client.deleteProject(input.uuid);
-            logger.toolComplete('delete_project', Date.now() - start);
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ deleted: true, uuid: input.uuid }, null, 2) }],
-            };
-        }
-        catch (err) {
-            if (err?.statusCode === 404 || err?.response?.status === 404)
-                return notFound(input.uuid);
-            throw err;
-        }
-    }
-    catch (error) {
-        logger.toolError('delete_project', error, Date.now() - start);
-        throw handleExternalServiceError(error, 'DebuggAI', 'delete_project');
-    }
-}

package/dist/handlers/updateProjectHandler.js

@@ -1,45 +0,0 @@
-import { Logger } from '../utils/logger.js';
-import { handleExternalServiceError } from '../utils/errors.js';
-import { DebuggAIServerClient } from '../services/index.js';
-import { config } from '../config/index.js';
-const logger = new Logger({ module: 'updateProjectHandler' });
-function notFound(uuid) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify({
-                    error: 'NotFound',
-                    message: `Project ${uuid} not found.`,
-                    uuid,
-                }, null, 2) }],
-        isError: true,
-    };
-}
-export async function updateProjectHandler(input, _context) {
-    const start = Date.now();
-    logger.toolStart('update_project', {
-        uuid: input.uuid,
-        patchKeys: Object.keys(input).filter(k => k !== 'uuid'),
-    });
-    try {
-        const client = new DebuggAIServerClient(config.api.key);
-        await client.init();
-        try {
-            const project = await client.updateProject(input.uuid, {
-                name: input.name,
-                description: input.description,
-            });
-            logger.toolComplete('update_project', Date.now() - start);
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ updated: true, project }, null, 2) }],
-            };
-        }
-        catch (err) {
-            if (err?.statusCode === 404 || err?.response?.status === 404)
-                return notFound(input.uuid);
-            throw err;
-        }
-    }
-    catch (error) {
-        logger.toolError('update_project', error, Date.now() - start);
-        throw handleExternalServiceError(error, 'DebuggAI', 'update_project');
-    }
-}

package/dist/tools/createEnvironment.js

@@ -1,46 +0,0 @@
-import { CreateEnvironmentInputSchema } from '../types/index.js';
-import { createEnvironmentHandler } from '../handlers/createEnvironmentHandler.js';
-const DESCRIPTION = `Create a new environment under a DebuggAI project. Both name and url are required (backend rejects standard environments without a URL). Optional description. Defaults to the project resolved from the current git repo; pass projectUuid to target a different project (get UUIDs via search_projects).
-
-OPTIONAL credentials seed: pass \`credentials: [{label, username, password, role?}]\` to create login credentials alongside the environment in a single call. Each cred is created best-effort; failures go to \`credentialWarnings\` without blocking env creation. Passwords are write-only and NEVER returned.
-
-Returns the created environment's uuid (and the seeded credentials, if any). Reference the env uuid when running check_app_in_browser.`;
-export function buildCreateEnvironmentTool() {
-    return {
-        name: 'create_environment',
-        title: 'Create Project Environment',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Short label for the environment (e.g. "staging", "production"). Required.',
-                    minLength: 1,
-                },
-                url: {
-                    type: 'string',
-                    description: 'Base URL for the environment (e.g. https://staging.example.com). Required.',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Optional: free-text description.',
-                },
-                projectUuid: {
-                    type: 'string',
-                    description: 'Optional: UUID of the target project. Defaults to the project resolved from the current git repo.',
-                },
-            },
-            required: ['name', 'url'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedCreateEnvironmentTool() {
-    const tool = buildCreateEnvironmentTool();
-    return {
-        ...tool,
-        inputSchema: CreateEnvironmentInputSchema,
-        handler: createEnvironmentHandler,
-    };
-}

package/dist/tools/createProject.js

@@ -1,27 +0,0 @@
-import { CreateProjectInputSchema } from '../types/index.js';
-import { createProjectHandler } from '../handlers/createProjectHandler.js';
-const DESCRIPTION = `Create a new DebuggAI project. Required: name, platform (e.g. "web"), plus a team and a repo. Team and repo each accept EITHER a UUID or a name: pass teamUuid OR teamName, and repoUuid OR repoName. Name resolution does a backend search with case-insensitive exact match (returns AmbiguousMatch with candidates on multiple hits, NotFound on no hit). The repo must be GitHub-linked to the account. Returns {created: true, project: {uuid, name, slug, platform, repoName, ...}}.`;
-export function buildCreateProjectTool() {
-    return {
-        name: 'create_project',
-        title: 'Create Project',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Project name. Required.', minLength: 1 },
-                platform: { type: 'string', description: 'Platform (e.g. "web"). Required.', minLength: 1 },
-                teamUuid: { type: 'string', description: 'Team UUID. Provide teamUuid OR teamName, not both.' },
-                teamName: { type: 'string', description: 'Team name (backend-resolved, case-insensitive exact match). Provide teamUuid OR teamName, not both.' },
-                repoUuid: { type: 'string', description: 'GitHub repo UUID. Provide repoUuid OR repoName, not both. Repo must be GitHub-linked.' },
-                repoName: { type: 'string', description: 'GitHub repo name, e.g. "org/repo" (backend-resolved, case-insensitive exact match). Provide repoUuid OR repoName, not both.' },
-            },
-            required: ['name', 'platform'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedCreateProjectTool() {
-    const tool = buildCreateProjectTool();
-    return { ...tool, inputSchema: CreateProjectInputSchema, handler: createProjectHandler };
-}

package/dist/tools/deleteEnvironment.js

@@ -1,23 +0,0 @@
-import { DeleteEnvironmentInputSchema } from '../types/index.js';
-import { deleteEnvironmentHandler } from '../handlers/deleteEnvironmentHandler.js';
-const DESCRIPTION = `Delete an environment by UUID. Returns {deleted: true, uuid}. Destructive — cascades per backend behavior (credentials under the env are typically removed). Defaults to the project resolved from the current git repo; pass projectUuid to target a different project. Returns isError:true with NotFound when the uuid doesn't exist or was already deleted.`;
-export function buildDeleteEnvironmentTool() {
-    return {
-        name: 'delete_environment',
-        title: 'Delete Environment',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'UUID of the environment to delete. Required.' },
-                projectUuid: { type: 'string', description: 'Optional: UUID of the target project. Defaults to git-auto-detect.' },
-            },
-            required: ['uuid'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedDeleteEnvironmentTool() {
-    const tool = buildDeleteEnvironmentTool();
-    return { ...tool, inputSchema: DeleteEnvironmentInputSchema, handler: deleteEnvironmentHandler };
-}

package/dist/tools/deleteProject.js

@@ -1,22 +0,0 @@
-import { DeleteProjectInputSchema } from '../types/index.js';
-import { deleteProjectHandler } from '../handlers/deleteProjectHandler.js';
-const DESCRIPTION = `Delete a project by UUID. Returns {deleted:true, uuid}. **DESTRUCTIVE** — removes the project and its associated environments, credentials, and test history. No undo. Returns isError:true + NotFound when already deleted or uuid doesn't exist.`;
-export function buildDeleteProjectTool() {
-    return {
-        name: 'delete_project',
-        title: 'Delete Project',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'UUID of the project to delete. Required.' },
-            },
-            required: ['uuid'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedDeleteProjectTool() {
-    const tool = buildDeleteProjectTool();
-    return { ...tool, inputSchema: DeleteProjectInputSchema, handler: deleteProjectHandler };
-}

package/dist/tools/searchEnvironments.js

@@ -1,35 +0,0 @@
-import { SearchEnvironmentsInputSchema } from '../types/index.js';
-import { searchEnvironmentsHandler } from '../handlers/searchEnvironmentsHandler.js';
-const DESCRIPTION = `Search or look up environments, with credentials expanded inline per environment.
-
-Two modes:
-  - uuid mode: {"uuid": "<env-uuid>"} → single env with full detail + its credentials. NotFound if the uuid doesn't exist.
-  - filter mode: omit uuid, optionally {"q": "<keyword>", "projectUuid", "page", "pageSize"} → paginated envs, each with its credentials.
-
-Project resolution: if projectUuid is omitted, the current git repo's origin is auto-resolved to a DebuggAI project. Returns {error:"NoProjectResolved", environments:[]} if neither is available.
-
-Credentials are returned inline per env as {uuid, label, username, role}. Password is NEVER returned — the handler defensively strips it regardless of what the service layer provides.
-
-Response: {project, filter, pageInfo, environments[]} — each environment includes a credentials[] array.`;
-export function buildSearchEnvironmentsTool() {
-    return {
-        name: 'search_environments',
-        title: 'Search Environments',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'Environment UUID. Returns single env with credentials inline. Mutually exclusive with projectUuid/q filter params.' },
-                projectUuid: { type: 'string', description: 'Override the auto-detected project. Used in filter mode.' },
-                q: { type: 'string', description: 'Free-text search over environment name. Mutually exclusive with uuid.' },
-                page: { type: 'number', description: 'Page number (1-indexed).' },
-                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedSearchEnvironmentsTool() {
-    const tool = buildSearchEnvironmentsTool();
-    return { ...tool, inputSchema: SearchEnvironmentsInputSchema, handler: searchEnvironmentsHandler };
-}

package/dist/tools/searchExecutions.js

@@ -1,31 +0,0 @@
-import { SearchExecutionsInputSchema } from '../types/index.js';
-import { searchExecutionsHandler } from '../handlers/searchExecutionsHandler.js';
-const DESCRIPTION = `Search or look up workflow executions (history of check_app_in_browser, trigger_crawl, and other workflow runs).
-
-Two modes:
-  - uuid mode: {"uuid": "<execution-uuid>"} → single execution with FULL detail including nodeExecutions, state, errorInfo. NotFound if the uuid doesn't exist.
-  - filter mode: {"status": "completed"|"running"|"failed"|"cancelled", "projectUuid": "...", "page", "pageSize"} → paginated summaries.
-
-Response shape: {filter, pageInfo, executions[]}. Summary items have outcome/status/durationMs/timestamps; uuid-mode items additionally have nodeExecutions + state + errorInfo.`;
-export function buildSearchExecutionsTool() {
-    return {
-        name: 'search_executions',
-        title: 'Search Workflow Executions',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'Execution UUID. Returns single execution with full detail. Mutually exclusive with projectUuid/status filters.' },
-                projectUuid: { type: 'string', description: 'Filter by project UUID.' },
-                status: { type: 'string', description: 'Filter by status: completed | running | failed | cancelled | pending.' },
-                page: { type: 'number', description: 'Page number (1-indexed).' },
-                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedSearchExecutionsTool() {
-    const tool = buildSearchExecutionsTool();
-    return { ...tool, inputSchema: SearchExecutionsInputSchema, handler: searchExecutionsHandler };
-}

package/dist/tools/searchProjects.js

@@ -1,30 +0,0 @@
-import { SearchProjectsInputSchema } from '../types/index.js';
-import { searchProjectsHandler } from '../handlers/searchProjectsHandler.js';
-const DESCRIPTION = `Search or look up projects.
-
-Two modes:
-  - uuid mode: pass {"uuid": "<project-uuid>"} → returns that project with the curated detail view (uuid, name, slug, platform, repoName, description, status, language, framework, timestamp, lastMod), or isError:true NotFound.
-  - filter mode: omit uuid, optionally pass {"q": "<keyword>", "page": 1, "pageSize": 20} → returns a paginated list of summaries (uuid, name, slug, repoName).
-
-Response shape is always {filter, pageInfo, projects[]}. uuid mode returns exactly one project; filter mode returns summaries.`;
-export function buildSearchProjectsTool() {
-    return {
-        name: 'search_projects',
-        title: 'Search Projects',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'Project UUID. When provided, returns exactly that project with full detail. Mutually exclusive with q.' },
-                q: { type: 'string', description: 'Free-text search (backend-side). Mutually exclusive with uuid.' },
-                page: { type: 'number', description: 'Page number (1-indexed). Default 1.' },
-                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedSearchProjectsTool() {
-    const tool = buildSearchProjectsTool();
-    return { ...tool, inputSchema: SearchProjectsInputSchema, handler: searchProjectsHandler };
-}