@gracker/smartperfetto 1.0.13 → 1.0.15

package/dist/agentv3/claudeMcpServer.js

@@ -37,6 +37,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_PHASE_SUMMARY_CHARS = exports.MCP_NAME_PREFIX = void 0;
+exports.normalizeOptionalToolString = normalizeOptionalToolString;
 exports.loadLearnedSqlFixPairs = loadLearnedSqlFixPairs;
 exports.createClaudeMcpServer = createClaudeMcpServer;
 const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
@@ -73,6 +74,12 @@ const caseLibrary_1 = require("../services/caseLibrary");
 const scopedKnowledgeStore_1 = require("../services/scopedKnowledgeStore");
 const mcpToolRegistry_1 = require("./mcpToolRegistry");
 const runtimePaths_1 = require("../runtimePaths");
+const defaultCodebaseServices_1 = require("../services/codebase/defaultCodebaseServices");
+const codeLookupLedger_1 = require("../services/codebase/codeLookupLedger");
+const patchProposer_1 = require("../services/codebase/patchProposer");
+const codeAwareFeature_1 = require("../services/codebase/codeAwareFeature");
+const lookupResponseFilter_1 = require("../services/rag/lookupResponseFilter");
+const symbolResolver_1 = require("../services/symbol/symbolResolver");
 /**
  * Process-wide RagStore singleton, lazily initialized on first MCP tool
  * call. Backs the `lookup_blog_knowledge` tool (Plan 55) and will back
@@ -207,6 +214,18 @@ function parseOptionalToolArrayInput(value) {
     }
     return parseToolArrayInput(value);
 }
+function normalizeOptionalToolString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const normalized = trimmed.toLowerCase();
+    if (normalized === 'null' || normalized === 'undefined' || normalized === 'none') {
+        return undefined;
+    }
+    return trimmed;
+}
 function parseToolStringArrayInput(value) {
     if (Array.isArray(value)) {
         return value.filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
@@ -618,6 +637,14 @@ function createClaudeMcpServer(options) {
     const skillNotesBudget = options.skillNotesBudget;
     const outputLanguage = options.outputLanguage ?? outputLanguage_1.DEFAULT_OUTPUT_LANGUAGE;
     const knowledgeScope = options.knowledgeScope;
+    const codeAwareMode = (0, codeAwareFeature_1.normalizeCodeAwareMode)(options.codeAwareMode);
+    const codebaseIds = Array.from(new Set(options.codebaseIds ?? [])).filter(Boolean);
+    const codebaseRegistry = options.codebaseRegistry ?? (0, defaultCodebaseServices_1.getDefaultCodebaseRegistry)();
+    const codeLookupLedger = options.codeLookupLedger ?? (options.sessionId ? codeLookupLedger_1.CodeLookupLedger.restore(options.sessionId, 12000, 2) : undefined);
+    const toolRequestScope = {
+        sessionId: options.sessionId ?? traceId,
+        hasCodebaseAccess: codeAwareMode !== 'off' && codebaseIds.length > 0,
+    };
     /** Normalize skill params: ensure process_name ↔ package are both set. */
     function normalizeSkillParams(params, defaultPackage) {
         const p = { ...params };
@@ -2295,13 +2322,50 @@ function createClaudeMcpServer(options) {
         'When the result carries `unsupportedReason` (license_blocked, index empty), the agent must say the source is unavailable and must NOT summarize, paraphrase, or invent content.', {
         query: zod_1.z.string().describe('Search query — typically a function or class name, or a behavior description.'),
         top_k: zod_1.z.number().int().min(1).max(20).optional().describe('Maximum hits returned (1-20, default 5).'),
-    }, async ({ query, top_k }) => {
+        codebase_id: zod_1.z.string().optional().describe('Optional whitelisted registered AOSP codebase id.'),
+        build_id: zod_1.z.string().optional().describe('Optional native build id filter.'),
+        symbol: zod_1.z.string().optional().describe('Exact symbol filter when known.'),
+        path_prefix: zod_1.z.string().optional().describe('Optional relative source path prefix.'),
+    }, async ({ query, top_k, codebase_id, build_id, symbol, path_prefix }) => {
+        const codebaseId = normalizeOptionalToolString(codebase_id);
+        const buildId = normalizeOptionalToolString(build_id);
+        const symbolExact = normalizeOptionalToolString(symbol);
+        const pathPrefix = normalizeOptionalToolString(path_prefix);
+        if (codebaseId && !codebaseIds.includes(codebaseId)) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Requested codebase is not whitelisted for this session' }) }],
+                isError: true,
+            };
+        }
         const store = getRagStore();
         const result = store.search(query, {
             topK: top_k ?? 5,
             kinds: ['aosp'],
+            ...(codebaseId ? { codebaseIds: [codebaseId] } : {}),
+            ...(buildId ? { buildId } : {}),
+            ...(symbolExact ? { symbolExact } : {}),
+            ...(pathPrefix ? { pathPrefix } : {}),
             scope: knowledgeScope,
         });
+        if (result.results.some(hit => hit.chunk?.registryOrigin === 'codebase_registry')) {
+            const scopedResult = {
+                ...result,
+                results: result.results.filter(hit => hit.chunk?.registryOrigin !== 'codebase_registry' ||
+                    (hit.chunk.codebaseId && codebaseIds.includes(hit.chunk.codebaseId))),
+            };
+            const filtered = await (0, lookupResponseFilter_1.filterRagLookup)(scopedResult, {
+                toolName: 'lookup_aosp_source',
+                turn: 0,
+                codebaseRegistry,
+                ledger: codeLookupLedger,
+                allowProviderSend: codeAwareMode === 'provider_send',
+                sessionId: options.sessionId,
+            });
+            await codeLookupLedger?.flush();
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: true, result: filtered }) }],
+            };
+        }
         return {
             content: [{ type: 'text', text: JSON.stringify(result) }],
         };
@@ -2314,17 +2378,254 @@ function createClaudeMcpServer(options) {
         'Read-only over the RagStore. When the result carries `unsupportedReason` (license_blocked, index empty), the agent must say the source is unavailable and must NOT summarize or invent.', {
         query: zod_1.z.string().describe('Search query — typically a tuning concept or vendor-specific knob.'),
         top_k: zod_1.z.number().int().min(1).max(20).optional().describe('Maximum hits returned (1-20, default 5).'),
-    }, async ({ query, top_k }) => {
+        codebase_id: zod_1.z.string().optional().describe('Optional whitelisted registered OEM codebase id.'),
+        vendor: zod_1.z.string().optional().describe('Optional vendor filter.'),
+    }, async ({ query, top_k, codebase_id, vendor }) => {
+        const codebaseId = normalizeOptionalToolString(codebase_id);
+        const vendorId = normalizeOptionalToolString(vendor);
+        if (codebaseId && !codebaseIds.includes(codebaseId)) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Requested codebase is not whitelisted for this session' }) }],
+                isError: true,
+            };
+        }
         const store = getRagStore();
         const result = store.search(query, {
             topK: top_k ?? 5,
             kinds: ['oem_sdk'],
+            ...(codebaseId ? { codebaseIds: [codebaseId] } : {}),
+            ...(vendorId ? { vendor: vendorId } : {}),
             scope: knowledgeScope,
         });
+        if (result.results.some(hit => hit.chunk?.registryOrigin === 'codebase_registry')) {
+            const scopedResult = {
+                ...result,
+                results: result.results.filter(hit => hit.chunk?.registryOrigin !== 'codebase_registry' ||
+                    (hit.chunk.codebaseId && codebaseIds.includes(hit.chunk.codebaseId))),
+            };
+            const filtered = await (0, lookupResponseFilter_1.filterRagLookup)(scopedResult, {
+                toolName: 'lookup_oem_sdk',
+                turn: 0,
+                codebaseRegistry,
+                ledger: codeLookupLedger,
+                allowProviderSend: codeAwareMode === 'provider_send',
+                sessionId: options.sessionId,
+            });
+            await codeLookupLedger?.flush();
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: true, result: filtered }) }],
+            };
+        }
         return {
             content: [{ type: 'text', text: JSON.stringify(result) }],
         };
     }, { annotations: { readOnlyHint: true } });
+    const listCodebases = (0, claude_agent_sdk_1.tool)('list_codebases', 'List the app/AOSP/kernel/OEM codebases explicitly whitelisted for this analysis session. ' +
+        'Returns metadata only; it never exposes local root paths.', {}, async () => {
+        const allowed = new Set(codebaseIds);
+        const codebases = codebaseRegistry.list()
+            .filter(ref => allowed.has(ref.codebaseId))
+            .map(ref => ({
+            codebaseId: ref.codebaseId,
+            kind: ref.kind,
+            displayName: ref.displayName,
+            indexGeneration: ref.indexGeneration,
+            chunkCount: ref.chunkCount,
+            eligibleForSendToProvider: ref.eligibleForSendToProvider,
+        }));
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true, codebases }) }],
+        };
+    }, { annotations: { readOnlyHint: true } });
+    const lookupAppSource = (0, claude_agent_sdk_1.tool)('lookup_app_source', 'Look up registered app source chunks for this analysis session. ' +
+        'Only whitelisted codebase IDs are accepted. In metadata_only mode the result carries file/symbol references without snippets.', {
+        query: zod_1.z.string().describe('Natural-language query, symbol, class, method, or file term.'),
+        top_k: zod_1.z.number().int().min(1).max(20).optional().describe('Maximum hits returned (1-20, default 5).'),
+        codebase_id: zod_1.z.string().optional().describe('Restrict to one whitelisted codebase id. Defaults to all session codebases.'),
+        symbol: zod_1.z.string().optional().describe('Exact symbol filter when known.'),
+        file_path: zod_1.z.string().optional().describe('Exact source file path relative to the registered root.'),
+        path_prefix: zod_1.z.string().optional().describe('Restrict lookup to a relative path prefix.'),
+    }, async ({ query, top_k, codebase_id, symbol, file_path, path_prefix }) => {
+        const codebaseId = normalizeOptionalToolString(codebase_id);
+        const symbolExact = normalizeOptionalToolString(symbol);
+        const filePath = normalizeOptionalToolString(file_path);
+        const pathPrefix = normalizeOptionalToolString(path_prefix);
+        const requestedIds = codebaseId ? [codebaseId] : codebaseIds;
+        const allowed = requestedIds.filter(id => codebaseIds.includes(id));
+        if (allowed.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: 'No requested codebase is whitelisted for this session' }),
+                    }],
+                isError: true,
+            };
+        }
+        const raw = getRagStore().search(query, {
+            topK: top_k ?? 5,
+            kinds: ['app_source'],
+            codebaseIds: allowed,
+            ...(symbolExact ? { symbolExact } : {}),
+            ...(filePath ? { filePathExact: filePath } : {}),
+            ...(pathPrefix ? { pathPrefix } : {}),
+            scope: knowledgeScope,
+        });
+        const filtered = await (0, lookupResponseFilter_1.filterRagLookup)(raw, {
+            toolName: 'lookup_app_source',
+            turn: 0,
+            codebaseRegistry,
+            ledger: codeLookupLedger,
+            allowProviderSend: codeAwareMode === 'provider_send',
+            sessionId: options.sessionId,
+        });
+        await codeLookupLedger?.flush();
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true, result: filtered }) }],
+        };
+    }, { annotations: { readOnlyHint: true } });
+    const lookupKernelSource = (0, claude_agent_sdk_1.tool)('lookup_kernel_source', 'Use when kernel/vendor source evidence is needed after trace evidence points at binder, scheduler, mm, io, or a kernel symbol. ' +
+        'Do NOT use for app or AOSP framework code. Prerequisites: a whitelisted kernel_source codebase, vendor or codebase_id, and a path_prefix/subsys. ' +
+        'Budget: top_k is capped at 20 and metadata_only sessions return CodeRef metadata without snippets. Outcomes: source hits, metadata-only hits, or an explicit unsupportedReason.', {
+        query: zod_1.z.string().describe('Kernel symbol, subsystem, or behavior query.'),
+        top_k: zod_1.z.number().int().min(1).max(20).optional().describe('Maximum hits returned (1-20, default 5).'),
+        codebase_id: zod_1.z.string().optional().describe('Restrict to one whitelisted kernel codebase id.'),
+        vendor: zod_1.z.string().optional().describe('Vendor id. Required when multiple kernel codebases are available and codebase_id is omitted.'),
+        symbol: zod_1.z.string().optional().describe('Exact symbol filter when known.'),
+        path_prefix: zod_1.z.string().optional().describe('Required subsystem path prefix, for example drivers/android/binder.'),
+    }, async ({ query, top_k, codebase_id, vendor, symbol, path_prefix }) => {
+        const codebaseId = normalizeOptionalToolString(codebase_id);
+        const vendorId = normalizeOptionalToolString(vendor);
+        const symbolExact = normalizeOptionalToolString(symbol);
+        const pathPrefix = normalizeOptionalToolString(path_prefix);
+        const requestedIds = codebaseId ? [codebaseId] : codebaseIds;
+        const allowed = requestedIds.filter(id => codebaseIds.includes(id));
+        if (allowed.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: 'No requested codebase is whitelisted for this session' }),
+                    }],
+                isError: true,
+            };
+        }
+        const kernelRefs = allowed
+            .map(id => codebaseRegistry.get(id))
+            .filter(ref => ref?.kind === 'kernel_source');
+        const vendors = new Set(kernelRefs.map(ref => ref.vendor).filter(Boolean));
+        if (!codebaseId && !vendorId && vendors.size > 1) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            success: false,
+                            unsupportedReason: 'vendor_required_for_multi_vendor_kernel_lookup',
+                            vendors: Array.from(vendors).sort(),
+                        }) }],
+                isError: true,
+            };
+        }
+        const raw = getRagStore().search(query, {
+            topK: top_k ?? 5,
+            kinds: ['kernel_source'],
+            codebaseIds: kernelRefs.map(ref => ref.codebaseId),
+            ...(vendorId ? { vendor: vendorId } : {}),
+            ...(symbolExact ? { symbolExact } : {}),
+            ...(pathPrefix ? { pathPrefix } : {}),
+            scope: knowledgeScope,
+        });
+        const filtered = await (0, lookupResponseFilter_1.filterRagLookup)(raw, {
+            toolName: 'lookup_kernel_source',
+            turn: 0,
+            codebaseRegistry,
+            ledger: codeLookupLedger,
+            allowProviderSend: codeAwareMode === 'provider_send',
+            sessionId: options.sessionId,
+        });
+        await codeLookupLedger?.flush();
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true, result: filtered }) }],
+        };
+    }, { annotations: { readOnlyHint: true } });
+    const resolveSymbol = (0, claude_agent_sdk_1.tool)('resolve_symbol', 'Use when trace frames or obfuscated names must be resolved to CodeRef metadata before source lookup. ' +
+        'Do NOT use to guess file:line when build_id is missing; return the degraded result instead. ' +
+        'Prerequisites: whitelisted codebase ids and indexed source/symbol metadata. Budget: top_k capped at 20. Outcomes: app, native/AOSP, or kernel candidates with degradation reasons.', {
+        symbol: zod_1.z.string().describe('Class, function, or method name to resolve.'),
+        kind: zod_1.z.enum(['app', 'native', 'kernel']).optional().describe('Resolution domain; default app.'),
+        codebase_id: zod_1.z.string().optional().describe('Restrict to one whitelisted codebase id. Defaults to all session codebases.'),
+        file_path: zod_1.z.string().optional().describe('Optional relative source file path for fallback matching.'),
+        build_id: zod_1.z.string().optional().describe('Optional build id. Missing build id returns a degraded result.'),
+        vendor: zod_1.z.string().optional().describe('Vendor id for kernel lookup.'),
+        top_k: zod_1.z.number().int().min(1).max(20).optional().describe('Maximum candidates returned.'),
+    }, async ({ symbol, kind, codebase_id, file_path, build_id, vendor, top_k }) => {
+        const codebaseId = normalizeOptionalToolString(codebase_id);
+        const filePath = normalizeOptionalToolString(file_path);
+        const buildId = normalizeOptionalToolString(build_id);
+        const vendorId = normalizeOptionalToolString(vendor);
+        const requestedIds = codebaseId ? [codebaseId] : codebaseIds;
+        const allowed = requestedIds.filter(id => codebaseIds.includes(id));
+        if (allowed.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: 'No requested codebase is whitelisted for this session' }),
+                    }],
+                isError: true,
+            };
+        }
+        const resolver = new symbolResolver_1.SymbolResolver(getRagStore());
+        const results = allowed.map(id => {
+            const ref = codebaseRegistry.get(id);
+            if (kind === 'kernel' || ref?.kind === 'kernel_source') {
+                return resolver.resolveKernel({
+                    symbol,
+                    codebaseId: id,
+                    vendor: vendorId ?? ref?.vendor,
+                    ...(buildId ? { buildId } : {}),
+                    topK: top_k ?? 5,
+                });
+            }
+            if (kind === 'native' || ref?.kind === 'aosp') {
+                return resolver.resolveNative({
+                    symbol,
+                    codebaseId: id,
+                    ...(buildId ? { buildId } : {}),
+                    topK: top_k ?? 5,
+                });
+            }
+            return resolver.resolveApp({
+                symbol,
+                codebaseId: id,
+                ...(filePath ? { filePath } : {}),
+                ...(buildId ? { buildId } : {}),
+                topK: top_k ?? 5,
+            });
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        success: results.some(result => result.success),
+                        results,
+                    }) }],
+        };
+    }, { annotations: { readOnlyHint: true } });
+    const proposePatch = (0, claude_agent_sdk_1.tool)('propose_patch', 'Use when the user asks for a concrete fix after successful code lookup. Do NOT use before lookup_app_source/lookup_kernel_source/lookup_aosp_source has returned prior contextChunkIds. ' +
+        'Prerequisites: all contextChunkIds must belong to one whitelisted codebase and provider_send consent must be enabled. Budget: patch attempts are capped by the session ledger. Outcomes: verified diff, non-copyable sketch, or unverified rejection.', {
+        context_chunk_ids: zod_1.z.array(zod_1.z.string()).min(1).describe('Chunk ids previously returned by a successful source lookup in this session.'),
+        problem: zod_1.z.string().describe('Performance problem the patch should address.'),
+        proposed_diff: zod_1.z.string().optional().describe('Optional unified diff to validate. Only returned to the user if git apply --check passes.'),
+        patch_sketch: zod_1.z.string().optional().describe('Optional high-level sketch when no verified diff is available.'),
+    }, async ({ context_chunk_ids, problem, proposed_diff, patch_sketch }) => {
+        const proposer = new patchProposer_1.PatchProposer(getRagStore(), codebaseRegistry, codeLookupLedger);
+        const result = proposer.propose({
+            contextChunkIds: context_chunk_ids,
+            problem,
+            ...(proposed_diff ? { proposedDiff: proposed_diff } : {}),
+            ...(patch_sketch ? { patchSketch: patch_sketch } : {}),
+            turn: 0,
+        });
+        await codeLookupLedger?.flush();
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ success: result.patchStatus !== 'unverified', result }) }],
+            ...(result.patchStatus === 'unverified' ? { isError: true } : {}),
+        };
+    }, { annotations: { readOnlyHint: false } });
     // recall_project_memory (Plan 44): pure-read recall over project +
     // world memory entries. Strict invariant: handler MUST NOT cause any
     // disk writes; ProjectMemory.recallProjectMemory() is enforced via
@@ -3498,6 +3799,11 @@ function createClaudeMcpServer(options) {
         registry.registerSdk(lookupBlogKnowledge, 'lookup_blog_knowledge', 'public');
         registry.registerSdk(lookupAospSource, 'lookup_aosp_source', 'public');
         registry.registerSdk(lookupOemSdk, 'lookup_oem_sdk', 'public');
+        registry.registerSdk(listCodebases, 'list_codebases', 'requires_codebase_permission');
+        registry.registerSdk(lookupAppSource, 'lookup_app_source', 'requires_codebase_permission');
+        registry.registerSdk(lookupKernelSource, 'lookup_kernel_source', 'requires_codebase_permission');
+        registry.registerSdk(resolveSymbol, 'resolve_symbol', 'requires_codebase_permission');
+        registry.registerSdk(proposePatch, 'propose_patch', 'requires_codebase_permission');
         registry.registerSdk(lookupBaseline, 'lookup_baseline', 'public');
         registry.registerSdk(compareBaselines, 'compare_baselines', 'public');
         registry.registerSdk(recallProjectMemory, 'recall_project_memory', 'public');
@@ -3534,9 +3840,9 @@ function createClaudeMcpServer(options) {
             registry.registerSdk(getComparisonContext, 'get_comparison_context', 'internal');
     }
     return {
-        server: registry.buildSdkServer(),
-        allowedTools: registry.buildAllowedTools(),
-        toolDefinitions: registry.list(),
+        server: registry.buildSdkServer({ scope: toolRequestScope }),
+        allowedTools: registry.buildAllowedTools(toolRequestScope),
+        toolDefinitions: registry.listForRequest(toolRequestScope),
     };
 }
 function evidenceHash(input) {