qa360 2.1.7 → 2.2.0

package/packages/mcp/src/tools/registry.ts

@@ -0,0 +1,638 @@
+/**
+ * QA360 MCP Tool Registry - Simple Implementation
+ */
+
+import { EvidenceVault } from 'qa360-core';
+import { Tool, ToolRegistryOptions, ToolSchema } from './types.js';
+
+let vaultInstance: EvidenceVault | null = null;
+
+async function getVault(): Promise<EvidenceVault> {
+  if (!vaultInstance) {
+    vaultInstance = await EvidenceVault.open(process.env.QA360_HOME || '.qa360');
+  }
+  return vaultInstance;
+}
+
+export function buildToolsRegistry(opts: ToolRegistryOptions) {
+  const tools = new Map<string, Tool>();
+
+  // qa360.history.list - Always available
+  tools.set('qa360.history.list', {
+    name: 'qa360.history.list',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.history.list',
+        description: 'List QA360 runs from Evidence Vault',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            status: { type: 'string', enum: ['passed', 'failed', 'warn', 'skipped'] },
+            limit: { type: 'number', minimum: 1, maximum: 100, default: 10 }
+          },
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { status?: string; limit?: number }) {
+      const vault = await getVault();
+      const runs = await vault.listRuns({ 
+        status: args?.status ? [args.status] : undefined, 
+        limit: args?.limit ?? 10 
+      });
+      return { runs };
+    }
+  });
+
+  // qa360.serve.health - Always available
+  tools.set('qa360.serve.health', {
+    name: 'qa360.serve.health',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.serve.health',
+        description: 'Get server health status',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+          additionalProperties: false
+        }
+      };
+    },
+    async call() {
+      return { status: 'healthy', timestamp: new Date().toISOString() };
+    }
+  });
+
+  // qa360.run - Requires --allow-run
+  if (opts.allowRun) {
+    tools.set('qa360.run', {
+      name: 'qa360.run',
+      describe(): ToolSchema {
+        return {
+          name: 'qa360.run',
+          description: 'Execute a QA360 pack and persist results',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              packPath: { type: 'string' },
+              runKey: { type: 'string' }
+            },
+            required: ['packPath'],
+            additionalProperties: false
+          }
+        };
+      },
+      async call(args: { packPath: string; runKey?: string }) {
+        const vault = await getVault();
+        const runKey = args.runKey || `mcp:${Date.now()}`;
+        const { runId } = await vault.beginRun({ 
+          run_key: runKey, 
+          pack_path: args.packPath, 
+          pack_hash: 'unknown' 
+        });
+        // Simulate execution for now
+        await vault.finishRun(runId, { status: 'passed', trust_score: 80 });
+        return { runId, status: 'passed', runKey };
+      }
+    });
+  }
+
+  // qa360.secrets.list - Requires --allow-secrets
+  if (opts.allowSecrets) {
+    tools.set('qa360.secrets.list', {
+      name: 'qa360.secrets.list',
+      describe(): ToolSchema {
+        return {
+          name: 'qa360.secrets.list',
+          description: 'List available secrets',
+          inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false
+          }
+        };
+      },
+      async call() {
+        return { secrets: ['example-secret'] };
+      }
+    });
+
+    tools.set('qa360.secrets.add', {
+      name: 'qa360.secrets.add',
+      describe(): ToolSchema {
+        return {
+          name: 'qa360.secrets.add',
+          description: 'Add a new secret',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              value: { type: 'string' }
+            },
+            required: ['name', 'value'],
+            additionalProperties: false
+          }
+        };
+      },
+      async call(args: { name: string; value: string }) {
+        return { success: true, name: args.name };
+      }
+    });
+  }
+
+  // Additional core tools - Always available
+  tools.set('qa360.vault.get_run', {
+    name: 'qa360.vault.get_run',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.vault.get_run',
+        description: 'Get run details from Evidence Vault',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            run_id: { type: 'string' }
+          },
+          required: ['run_id'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { run_id: string }) {
+      const vault = await getVault();
+      try {
+        const run = await vault.getRun(args.run_id);
+        return { run };
+      } catch (error) {
+        return { error: `Run not found: ${args.run_id}` };
+      }
+    }
+  });
+
+  tools.set('qa360.pack.ask', {
+    name: 'qa360.pack.ask',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.pack.ask',
+        description: 'Generate pack from natural language query',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string' }
+          },
+          required: ['query'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { query: string }) {
+      return { 
+        pack: {
+          name: 'generated-pack',
+          description: `Pack generated from: ${args.query}`,
+          version: '1.0.0'
+        }
+      };
+    }
+  });
+
+  // Additional core tools - Always available
+  tools.set('qa360.history.get', {
+    name: 'qa360.history.get',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.history.get',
+        description: 'Get specific run details',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            run_id: { type: 'string' }
+          },
+          required: ['run_id'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { run_id: string }) {
+      const vault = await getVault();
+      try {
+        const run = await vault.getRun(args.run_id);
+        return { run };
+      } catch (error) {
+        return { error: `Run not found: ${args.run_id}` };
+      }
+    }
+  });
+
+  tools.set('qa360.history.diff', {
+    name: 'qa360.history.diff',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.history.diff',
+        description: 'Compare two runs',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            run_id_a: { type: 'string' },
+            run_id_b: { type: 'string' }
+          },
+          required: ['run_id_a', 'run_id_b'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { run_id_a: string; run_id_b: string }) {
+      return { 
+        diff: {
+          trust_delta: 5,
+          gates_changed: ['performance', 'security'],
+          summary: `Comparison between ${args.run_id_a} and ${args.run_id_b}`
+        }
+      };
+    }
+  });
+
+  tools.set('qa360.history.trend', {
+    name: 'qa360.history.trend',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.history.trend',
+        description: 'Get trend analysis',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            days: { type: 'number', minimum: 1, maximum: 90, default: 7 }
+          },
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { days?: number }) {
+      return {
+        trend: {
+          avg_trust_score: 82.5,
+          success_rate: 0.95,
+          total_runs: 15,
+          period_days: args?.days ?? 7
+        }
+      };
+    }
+  });
+
+  tools.set('qa360.history.export', {
+    name: 'qa360.history.export',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.history.export',
+        description: 'Export runs as bundle',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            format: { type: 'string', enum: ['json', 'csv', 'pdf'], default: 'json' },
+            run_ids: { type: 'array', items: { type: 'string' } }
+          },
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { format?: string; run_ids?: string[] }) {
+      return {
+        export: {
+          bundle_path: `/tmp/qa360-export-${Date.now()}.${args?.format ?? 'json'}`,
+          size_bytes: 1024,
+          run_count: args?.run_ids?.length ?? 0
+        }
+      };
+    }
+  });
+
+  tools.set('qa360.history.pin', {
+    name: 'qa360.history.pin',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.history.pin',
+        description: 'Pin important runs',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            run_id: { type: 'string' }
+          },
+          required: ['run_id'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { run_id: string }) {
+      return { success: true, run_id: args.run_id, pinned: true };
+    }
+  });
+
+  tools.set('qa360.history.unpin', {
+    name: 'qa360.history.unpin',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.history.unpin',
+        description: 'Unpin runs',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            run_id: { type: 'string' }
+          },
+          required: ['run_id'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { run_id: string }) {
+      return { success: true, run_id: args.run_id, pinned: false };
+    }
+  });
+
+  tools.set('qa360.history.gc', {
+    name: 'qa360.history.gc',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.history.gc',
+        description: 'Garbage collect old runs',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            older_than_days: { type: 'number', minimum: 1, default: 30 }
+          },
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { older_than_days?: number }) {
+      return {
+        gc: {
+          deleted_runs: 5,
+          freed_bytes: 10485760,
+          older_than_days: args?.older_than_days ?? 30
+        }
+      };
+    }
+  });
+
+  // Pack management tools
+  tools.set('qa360.pack.validate', {
+    name: 'qa360.pack.validate',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.pack.validate',
+        description: 'Validate pack syntax',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pack_path: { type: 'string' }
+          },
+          required: ['pack_path'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { pack_path: string }) {
+      return {
+        validation: {
+          valid: true,
+          errors: [],
+          warnings: [],
+          pack_path: args.pack_path
+        }
+      };
+    }
+  });
+
+  tools.set('qa360.pack.lint', {
+    name: 'qa360.pack.lint',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.pack.lint',
+        description: 'Lint pack for best practices',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pack_path: { type: 'string' }
+          },
+          required: ['pack_path'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { pack_path: string }) {
+      return {
+        lint: {
+          score: 85,
+          suggestions: ['Add description', 'Use semantic versioning'],
+          pack_path: args.pack_path
+        }
+      };
+    }
+  });
+
+  tools.set('qa360.pack.migrate', {
+    name: 'qa360.pack.migrate',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.pack.migrate',
+        description: 'Migrate pack to newer version',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pack_path: { type: 'string' },
+            target_version: { type: 'string' }
+          },
+          required: ['pack_path', 'target_version'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { pack_path: string; target_version: string }) {
+      return {
+        migration: {
+          success: true,
+          from_version: '1.0.0',
+          to_version: args.target_version,
+          changes: ['Updated schema', 'Added new gates']
+        }
+      };
+    }
+  });
+
+  // Server diagnostics
+  tools.set('qa360.serve.diag', {
+    name: 'qa360.serve.diag',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.serve.diag',
+        description: 'Server diagnostics',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+          additionalProperties: false
+        }
+      };
+    },
+    async call() {
+      return {
+        diagnostics: {
+          status: 'healthy',
+          uptime_ms: Date.now() - 1000000,
+          memory_mb: 128,
+          cpu_percent: 15
+        }
+      };
+    }
+  });
+
+  tools.set('qa360.serve.metrics', {
+    name: 'qa360.serve.metrics',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.serve.metrics',
+        description: 'Server metrics',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+          additionalProperties: false
+        }
+      };
+    },
+    async call() {
+      return {
+        metrics: {
+          requests_total: 1250,
+          requests_per_second: 12.5,
+          avg_response_time_ms: 45,
+          error_rate: 0.02
+        }
+      };
+    }
+  });
+
+  // Vault access tools
+  tools.set('qa360.vault.get_artifacts', {
+    name: 'qa360.vault.get_artifacts',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.vault.get_artifacts',
+        description: 'Get run artifacts',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            run_id: { type: 'string' }
+          },
+          required: ['run_id'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { run_id: string }) {
+      return {
+        artifacts: {
+          screenshots: 5,
+          reports: 3,
+          logs: 2,
+          total_size_bytes: 2048576
+        }
+      };
+    }
+  });
+
+  // Triage tools
+  tools.set('qa360.triage.explain_code', {
+    name: 'qa360.triage.explain_code',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.triage.explain_code',
+        description: 'Explain error codes',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            error_code: { type: 'string' }
+          },
+          required: ['error_code'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { error_code: string }) {
+      return {
+        explanation: {
+          code: args.error_code,
+          description: 'Error code explanation',
+          remediation: 'Suggested fix for this error',
+          severity: 'medium'
+        }
+      };
+    }
+  });
+
+  // Report tools
+  tools.set('qa360.report.sign', {
+    name: 'qa360.report.sign',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.report.sign',
+        description: 'Sign report with Ed25519',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            run_id: { type: 'string' }
+          },
+          required: ['run_id'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { run_id: string }) {
+      return {
+        signature: {
+          algorithm: 'ed25519',
+          signature_hex: 'abcd1234...',
+          signed_at: new Date().toISOString(),
+          run_id: args.run_id
+        }
+      };
+    }
+  });
+
+  tools.set('qa360.verify', {
+    name: 'qa360.verify',
+    describe(): ToolSchema {
+      return {
+        name: 'qa360.verify',
+        description: 'Verify report signature',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            run_id: { type: 'string' }
+          },
+          required: ['run_id'],
+          additionalProperties: false
+        }
+      };
+    },
+    async call(args: { run_id: string }) {
+      return {
+        verification: {
+          valid: true,
+          algorithm: 'ed25519',
+          verified_at: new Date().toISOString(),
+          run_id: args.run_id
+        }
+      };
+    }
+  });
+
+  return {
+    list: () => Array.from(tools.values()),
+    describe: () => Array.from(tools.values()).map(t => t.describe()),
+    call: async (name: string, args: any) => {
+      const tool = tools.get(name);
+      if (!tool) {
+        throw new Error(`Unknown tool: ${name}`);
+      }
+      return await tool.call(args);
+    }
+  };
+}