solidity-argus 0.3.3 → 0.3.5

package/src/tools/report-preflight.ts

@@ -0,0 +1,79 @@
+import {
+  collectToolLifecycleIssues,
+  hasSessionCreated,
+  hasSessionDeleted,
+} from "../features/persistent-state/run-finalizer"
+import type { AuditEvent } from "../state/schemas"
+
+export interface PreflightResult {
+  passed: boolean
+  orphanedTools: string[]
+  missingLifecycle: string[]
+  missingRequiredTools: string[]
+  warnings: string[]
+}
+
+export interface PreflightOptions {
+  requiredTools?: string[]
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value as Record<string, unknown>
+  }
+  return null
+}
+
+function hasCompletedTool(events: AuditEvent[], toolName: string): boolean {
+  for (const event of events) {
+    if (event.type !== "tool.completed") {
+      continue
+    }
+
+    const payload = asRecord(event.payload)
+    if (!payload) {
+      continue
+    }
+
+    const name = payload.name
+    const tool = payload.tool
+    if (name === toolName || tool === toolName) {
+      return true
+    }
+  }
+
+  return false
+}
+
+export function checkReportPreflight(
+  events: AuditEvent[],
+  options: PreflightOptions = {},
+): PreflightResult {
+  const missingLifecycle: string[] = []
+  if (!hasSessionCreated(events)) {
+    missingLifecycle.push("session.created")
+  }
+  if (!hasSessionDeleted(events)) {
+    missingLifecycle.push("session.deleted")
+  }
+
+  const { orphanedToolCallIds, malformedEvents } = collectToolLifecycleIssues(events)
+
+  const missingRequiredTools: string[] = []
+  for (const requiredTool of options.requiredTools ?? []) {
+    if (!hasCompletedTool(events, requiredTool)) {
+      missingRequiredTools.push(requiredTool)
+    }
+  }
+
+  return {
+    passed:
+      orphanedToolCallIds.length === 0 &&
+      missingLifecycle.length === 0 &&
+      missingRequiredTools.length === 0,
+    orphanedTools: orphanedToolCallIds,
+    missingLifecycle,
+    missingRequiredTools,
+    warnings: malformedEvents,
+  }
+}

package/src/tools/solodit-search-tool.ts

@@ -245,33 +245,22 @@ export async function executeSoloditSearch(
 
   context.metadata({ title: `Solodit search: ${query}` })
 
-  // Belt-and-suspenders: check if Solodit MCP is available, with 3s retry
-  // Skip check in test environment
-  if (!soloditAvailable && process.env.NODE_ENV !== "test") {
-    // Wait up to 3s for monitoring to flip the flag
-    for (let i = 0; i < 3 && !soloditAvailable; i++) {
-      await Bun.sleep(1000)
-    }
-    if (!soloditAvailable) {
-      return {
-        results: [],
-        totalFound: 0,
-        query,
-        error:
-          "Solodit MCP not available — server did not start. Results limited to local patterns.",
-      }
-    }
-  }
-
   const mcpCaller = callMcpTool ?? (hasMcpCapability(context) ? context.callMcpTool : undefined)
 
+  // When MCP is unavailable or no caller exists, go straight to HTTP fallback
   if (!mcpCaller) {
+    const reason = !soloditAvailable ? "MCP unavailable" : "no callMcpTool"
+    logger.debug(`[solodit] ${reason} — using HTTP fallback for query: ${query}`)
     return callSoloditHttp(query, limit, args.severity, port)
   }
 
+  // MCP path: try each tool name in order, fall back to HTTP on any failure
   let hadMcpError = false
   for (const toolName of SOLODIT_MCP_TOOLS) {
     try {
+      logger.debug(
+        `[solodit] Trying MCP tool '${toolName}' on server '${SOLODIT_MCP_SERVER}' for query: ${query}`,
+      )
       const response = await mcpCaller(
         SOLODIT_MCP_SERVER,
         toolName,
@@ -279,6 +268,7 @@ export async function executeSoloditSearch(
       )
 
       if (hasMcpError(response)) {
+        logger.debug(`[solodit] MCP tool '${toolName}' returned error envelope — trying next tool`)
         hadMcpError = true
         continue
       }
@@ -288,22 +278,23 @@ export async function executeSoloditSearch(
         args.severity,
       )
 
+      logger.debug(`[solodit] MCP tool '${toolName}' succeeded — found ${findings.length} findings`)
       return {
         results: findings.slice(0, limit),
         totalFound: findings.length,
         query,
       }
     } catch {
+      logger.debug(`[solodit] MCP tool '${toolName}' threw — trying next tool`)
       hadMcpError = true
     }
   }
 
-  const fallback = await callSoloditHttp(query, limit, args.severity, port)
-  if (fallback.error || hadMcpError) {
-    return fallback
-  }
-
-  return fallback
+  // All MCP tools failed — fall back to HTTP
+  logger.debug(
+    `[solodit] All MCP tools failed (hadMcpError=${hadMcpError}) — falling back to HTTP for query: ${query}`,
+  )
+  return callSoloditHttp(query, limit, args.severity, port)
 }
 
 export function createSoloditSearchTool(port: number = DEFAULT_SOLODIT_PORT): ToolDefinition {

package/src/utils/solodit-health.ts

@@ -5,6 +5,17 @@ export interface SoloditHealthStatus {
   error?: string
 }
 
+const MCP_INITIALIZE_BODY = JSON.stringify({
+  jsonrpc: "2.0",
+  method: "initialize",
+  params: {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "argus-health-probe", version: "1.0.0" },
+  },
+  id: 1,
+})
+
 export async function checkSoloditHealth(
   port: number,
   enabled: boolean,
@@ -15,8 +26,15 @@ export async function checkSoloditHealth(
 
   try {
     const response = await fetch(`http://localhost:${port}/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+      },
+      body: MCP_INITIALIZE_BODY,
       signal: AbortSignal.timeout(2000),
     })
+    // Any 2xx response means the MCP server is reachable (even if body contains JSON-RPC error)
     return { reachable: response.ok, enabled: true, port }
   } catch (error) {
     return {