subagent-cli 0.2.9 → 0.3.1

package/src/hooks/toolPermission/permissionLogging.ts

@@ -1,238 +0,0 @@
-// Centralized analytics/telemetry logging for tool permission decisions.
-// All permission approve/reject events flow through logPermissionDecision(),
-// which fans out to Statsig analytics, OTel telemetry, and code-edit metrics.
-import { feature } from 'src/_stubs/bun-bundle.js'
-import {
-  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
-  logEvent,
-} from 'src/services/analytics/index.js'
-import { sanitizeToolNameForAnalytics } from 'src/services/analytics/metadata.js'
-import { getCodeEditToolDecisionCounter } from '../../bootstrap/state.js'
-import type { Tool as ToolType, ToolUseContext } from '../../Tool.js'
-import { getLanguageName } from '../../utils/cliHighlight.js'
-import { SandboxManager } from '../../utils/sandbox/sandbox-adapter.js'
-import { logOTelEvent } from '../../utils/telemetry/events.js'
-import type {
-  PermissionApprovalSource,
-  PermissionRejectionSource,
-} from './PermissionContext.js'
-
-type PermissionLogContext = {
-  tool: ToolType
-  input: unknown
-  toolUseContext: ToolUseContext
-  messageId: string
-  toolUseID: string
-}
-
-// Discriminated union: 'accept' pairs with approval sources, 'reject' with rejection sources
-type PermissionDecisionArgs =
-  | { decision: 'accept'; source: PermissionApprovalSource | 'config' }
-  | { decision: 'reject'; source: PermissionRejectionSource | 'config' }
-
-const CODE_EDITING_TOOLS = ['Edit', 'Write', 'NotebookEdit']
-
-function isCodeEditingTool(toolName: string): boolean {
-  return CODE_EDITING_TOOLS.includes(toolName)
-}
-
-// Builds OTel counter attributes for code editing tools, enriching with
-// language when the tool's target file path can be extracted from input
-async function buildCodeEditToolAttributes(
-  tool: ToolType,
-  input: unknown,
-  decision: 'accept' | 'reject',
-  source: string,
-): Promise<Record<string, string>> {
-  // Derive language from file path if the tool exposes one (e.g., Edit, Write)
-  let language: string | undefined
-  if (tool.getPath && input) {
-    const parseResult = tool.inputSchema.safeParse(input)
-    if (parseResult.success) {
-      const filePath = tool.getPath(parseResult.data)
-      if (filePath) {
-        language = await getLanguageName(filePath)
-      }
-    }
-  }
-
-  return {
-    decision,
-    source,
-    tool_name: tool.name,
-    ...(language && { language }),
-  }
-}
-
-// Flattens structured source into a string label for analytics/OTel events
-function sourceToString(
-  source: PermissionApprovalSource | PermissionRejectionSource,
-): string {
-  if (
-    (feature('BASH_CLASSIFIER') || feature('TRANSCRIPT_CLASSIFIER')) &&
-    source.type === 'classifier'
-  ) {
-    return 'classifier'
-  }
-  switch (source.type) {
-    case 'hook':
-      return 'hook'
-    case 'user':
-      return source.permanent ? 'user_permanent' : 'user_temporary'
-    case 'user_abort':
-      return 'user_abort'
-    case 'user_reject':
-      return 'user_reject'
-    default:
-      return 'unknown'
-  }
-}
-
-function baseMetadata(
-  messageId: string,
-  toolName: string,
-  waitMs: number | undefined,
-): { [key: string]: boolean | number | undefined } {
-  return {
-    messageID:
-      messageId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
-    toolName: sanitizeToolNameForAnalytics(toolName),
-    sandboxEnabled: SandboxManager.isSandboxingEnabled(),
-    // Only include wait time when the user was actually prompted (not auto-approved)
-    ...(waitMs !== undefined && { waiting_for_user_permission_ms: waitMs }),
-  }
-}
-
-// Emits a distinct analytics event name per approval source for funnel analysis
-function logApprovalEvent(
-  tool: ToolType,
-  messageId: string,
-  source: PermissionApprovalSource | 'config',
-  waitMs: number | undefined,
-): void {
-  if (source === 'config') {
-    // Auto-approved by allowlist in settings -- no user wait time
-    logEvent(
-      'tengu_tool_use_granted_in_config',
-      baseMetadata(messageId, tool.name, undefined),
-    )
-    return
-  }
-  if (
-    (feature('BASH_CLASSIFIER') || feature('TRANSCRIPT_CLASSIFIER')) &&
-    source.type === 'classifier'
-  ) {
-    logEvent(
-      'tengu_tool_use_granted_by_classifier',
-      baseMetadata(messageId, tool.name, waitMs),
-    )
-    return
-  }
-  switch (source.type) {
-    case 'user':
-      logEvent(
-        source.permanent
-          ? 'tengu_tool_use_granted_in_prompt_permanent'
-          : 'tengu_tool_use_granted_in_prompt_temporary',
-        baseMetadata(messageId, tool.name, waitMs),
-      )
-      break
-    case 'hook':
-      logEvent('tengu_tool_use_granted_by_permission_hook', {
-        ...baseMetadata(messageId, tool.name, waitMs),
-        permanent: source.permanent ?? false,
-      })
-      break
-    default:
-      break
-  }
-}
-
-// Rejections share a single event name, differentiated by metadata fields
-function logRejectionEvent(
-  tool: ToolType,
-  messageId: string,
-  source: PermissionRejectionSource | 'config',
-  waitMs: number | undefined,
-): void {
-  if (source === 'config') {
-    // Denied by denylist in settings
-    logEvent(
-      'tengu_tool_use_denied_in_config',
-      baseMetadata(messageId, tool.name, undefined),
-    )
-    return
-  }
-  logEvent('tengu_tool_use_rejected_in_prompt', {
-    ...baseMetadata(messageId, tool.name, waitMs),
-    // Distinguish hook rejections from user rejections via separate fields
-    ...(source.type === 'hook'
-      ? { isHook: true }
-      : {
-          hasFeedback:
-            source.type === 'user_reject' ? source.hasFeedback : false,
-        }),
-  })
-}
-
-// Single entry point for all permission decision logging. Called by permission
-// handlers after every approve/reject. Fans out to: analytics events, OTel
-// telemetry, code-edit OTel counters, and toolUseContext decision storage.
-function logPermissionDecision(
-  ctx: PermissionLogContext,
-  args: PermissionDecisionArgs,
-  permissionPromptStartTimeMs?: number,
-): void {
-  const { tool, input, toolUseContext, messageId, toolUseID } = ctx
-  const { decision, source } = args
-
-  const waiting_for_user_permission_ms =
-    permissionPromptStartTimeMs !== undefined
-      ? Date.now() - permissionPromptStartTimeMs
-      : undefined
-
-  // Log the analytics event
-  if (args.decision === 'accept') {
-    logApprovalEvent(
-      tool,
-      messageId,
-      args.source,
-      waiting_for_user_permission_ms,
-    )
-  } else {
-    logRejectionEvent(
-      tool,
-      messageId,
-      args.source,
-      waiting_for_user_permission_ms,
-    )
-  }
-
-  const sourceString = source === 'config' ? 'config' : sourceToString(source)
-
-  // Track code editing tool metrics
-  if (isCodeEditingTool(tool.name)) {
-    void buildCodeEditToolAttributes(tool, input, decision, sourceString).then(
-      attributes => getCodeEditToolDecisionCounter()?.add(1, attributes),
-    )
-  }
-
-  // Persist decision on the context so downstream code can inspect what happened
-  if (!toolUseContext.toolDecisions) {
-    toolUseContext.toolDecisions = new Map()
-  }
-  toolUseContext.toolDecisions.set(toolUseID, {
-    source: sourceString,
-    decision,
-    timestamp: Date.now(),
-  })
-
-  void logOTelEvent('tool_decision', {
-    decision,
-    source: sourceString,
-    tool_name: sanitizeToolNameForAnalytics(tool.name),
-  })
-}
-
-export { isCodeEditingTool, buildCodeEditToolAttributes, logPermissionDecision }
-export type { PermissionLogContext, PermissionDecisionArgs }

package/src/hooks/unifiedSuggestions.ts

@@ -1,202 +0,0 @@
-import Fuse from 'fuse.js'
-import { basename } from 'path'
-import type { SuggestionItem } from 'src/components/PromptInput/PromptInputFooterSuggestions.js'
-import { generateFileSuggestions } from 'src/hooks/fileSuggestions.js'
-import type { ServerResource } from 'src/services/mcp/types.js'
-import { getAgentColor } from 'src/tools/AgentTool/agentColorManager.js'
-import type { AgentDefinition } from 'src/tools/AgentTool/loadAgentsDir.js'
-import { truncateToWidth } from 'src/utils/format.js'
-import { logError } from 'src/utils/log.js'
-import type { Theme } from 'src/utils/theme.js'
-
-type FileSuggestionSource = {
-  type: 'file'
-  displayText: string
-  description?: string
-  path: string
-  filename: string
-  score?: number
-}
-
-type McpResourceSuggestionSource = {
-  type: 'mcp_resource'
-  displayText: string
-  description: string
-  server: string
-  uri: string
-  name: string
-}
-
-type AgentSuggestionSource = {
-  type: 'agent'
-  displayText: string
-  description: string
-  agentType: string
-  color?: keyof Theme
-}
-
-type SuggestionSource =
-  | FileSuggestionSource
-  | McpResourceSuggestionSource
-  | AgentSuggestionSource
-
-/**
- * Creates a unified suggestion item from a source
- */
-function createSuggestionFromSource(source: SuggestionSource): SuggestionItem {
-  switch (source.type) {
-    case 'file':
-      return {
-        id: `file-${source.path}`,
-        displayText: source.displayText,
-        description: source.description,
-      }
-    case 'mcp_resource':
-      return {
-        id: `mcp-resource-${source.server}__${source.uri}`,
-        displayText: source.displayText,
-        description: source.description,
-      }
-    case 'agent':
-      return {
-        id: `agent-${source.agentType}`,
-        displayText: source.displayText,
-        description: source.description,
-        color: source.color,
-      }
-  }
-}
-
-const MAX_UNIFIED_SUGGESTIONS = 15
-const DESCRIPTION_MAX_LENGTH = 60
-
-function truncateDescription(description: string): string {
-  return truncateToWidth(description, DESCRIPTION_MAX_LENGTH)
-}
-
-function generateAgentSuggestions(
-  agents: AgentDefinition[],
-  query: string,
-  showOnEmpty = false,
-): AgentSuggestionSource[] {
-  if (!query && !showOnEmpty) {
-    return []
-  }
-
-  try {
-    const agentSources: AgentSuggestionSource[] = agents.map(agent => ({
-      type: 'agent' as const,
-      displayText: `${agent.agentType} (agent)`,
-      description: truncateDescription(agent.whenToUse),
-      agentType: agent.agentType,
-      color: getAgentColor(agent.agentType),
-    }))
-
-    if (!query) {
-      return agentSources
-    }
-
-    const queryLower = query.toLowerCase()
-    return agentSources.filter(
-      agent =>
-        agent.agentType.toLowerCase().includes(queryLower) ||
-        agent.displayText.toLowerCase().includes(queryLower),
-    )
-  } catch (error) {
-    logError(error as Error)
-    return []
-  }
-}
-
-export async function generateUnifiedSuggestions(
-  query: string,
-  mcpResources: Record<string, ServerResource[]>,
-  agents: AgentDefinition[],
-  showOnEmpty = false,
-): Promise<SuggestionItem[]> {
-  if (!query && !showOnEmpty) {
-    return []
-  }
-
-  const [fileSuggestions, agentSources] = await Promise.all([
-    generateFileSuggestions(query, showOnEmpty),
-    Promise.resolve(generateAgentSuggestions(agents, query, showOnEmpty)),
-  ])
-
-  const fileSources: FileSuggestionSource[] = fileSuggestions.map(
-    suggestion => ({
-      type: 'file' as const,
-      displayText: suggestion.displayText,
-      description: suggestion.description,
-      path: suggestion.displayText, // Use displayText as path for files
-      filename: basename(suggestion.displayText),
-      score: (suggestion.metadata as { score?: number } | undefined)?.score,
-    }),
-  )
-
-  const mcpSources: McpResourceSuggestionSource[] = Object.values(mcpResources)
-    .flat()
-    .map(resource => ({
-      type: 'mcp_resource' as const,
-      displayText: `${resource.server}:${resource.uri}`,
-      description: truncateDescription(
-        resource.description || resource.name || resource.uri,
-      ),
-      server: resource.server,
-      uri: resource.uri,
-      name: resource.name || resource.uri,
-    }))
-
-  if (!query) {
-    const allSources = [...fileSources, ...mcpSources, ...agentSources]
-    return allSources
-      .slice(0, MAX_UNIFIED_SUGGESTIONS)
-      .map(createSuggestionFromSource)
-  }
-
-  const nonFileSources: SuggestionSource[] = [...mcpSources, ...agentSources]
-
-  // Score non-file sources with Fuse.js
-  // File sources are already scored by Rust/nucleo
-  type ScoredSource = { source: SuggestionSource; score: number }
-  const scoredResults: ScoredSource[] = []
-
-  // Add file sources with their nucleo scores (already 0-1, lower is better)
-  for (const fileSource of fileSources) {
-    scoredResults.push({
-      source: fileSource,
-      score: fileSource.score ?? 0.5, // Default to middle score if missing
-    })
-  }
-
-  // Score non-file sources with Fuse.js and add them
-  if (nonFileSources.length > 0) {
-    const fuse = new Fuse(nonFileSources, {
-      includeScore: true,
-      threshold: 0.6, // Allow more matches through, we'll sort by score
-      keys: [
-        { name: 'displayText', weight: 2 },
-        { name: 'name', weight: 3 },
-        { name: 'server', weight: 1 },
-        { name: 'description', weight: 1 },
-        { name: 'agentType', weight: 3 },
-      ],
-    })
-
-    const fuseResults = fuse.search(query, { limit: MAX_UNIFIED_SUGGESTIONS })
-    for (const result of fuseResults) {
-      scoredResults.push({
-        source: result.item,
-        score: result.score ?? 0.5,
-      })
-    }
-  }
-
-  // Sort all results by score (lower is better) and return top results
-  scoredResults.sort((a, b) => a.score - b.score)
-
-  return scoredResults
-    .slice(0, MAX_UNIFIED_SUGGESTIONS)
-    .map(r => r.source)
-    .map(createSuggestionFromSource)
-}

package/src/hooks/useAfterFirstRender.ts

@@ -1,17 +0,0 @@
-import { useEffect } from 'react'
-import { isEnvTruthy } from '../utils/envUtils.js'
-
-export function useAfterFirstRender(): void {
-  useEffect(() => {
-    if (
-      process.env.USER_TYPE === 'ant' &&
-      isEnvTruthy(process.env.CLAUDE_CODE_EXIT_AFTER_FIRST_RENDER)
-    ) {
-      process.stderr.write(
-        `\nStartup time: ${Math.round(process.uptime() * 1000)}ms\n`,
-      )
-      // eslint-disable-next-line custom-rules/no-process-exit
-      process.exit(0)
-    }
-  }, [])
-}

package/src/hooks/useApiKeyVerification.ts

@@ -1,84 +0,0 @@
-import { useCallback, useState } from 'react'
-import { getIsNonInteractiveSession } from '../bootstrap/state.js'
-import { verifyApiKey } from '../services/api/claude.js'
-import {
-  getAnthropicApiKeyWithSource,
-  getApiKeyFromApiKeyHelper,
-  isAnthropicAuthEnabled,
-  isClaudeAISubscriber,
-} from '../utils/auth.js'
-
-export type VerificationStatus =
-  | 'loading'
-  | 'valid'
-  | 'invalid'
-  | 'missing'
-  | 'error'
-
-export type ApiKeyVerificationResult = {
-  status: VerificationStatus
-  reverify: () => Promise<void>
-  error: Error | null
-}
-
-export function useApiKeyVerification(): ApiKeyVerificationResult {
-  const [status, setStatus] = useState<VerificationStatus>(() => {
-    if (!isAnthropicAuthEnabled() || isClaudeAISubscriber()) {
-      return 'valid'
-    }
-    // Use skipRetrievingKeyFromApiKeyHelper to avoid executing apiKeyHelper
-    // before trust dialog is shown (security: prevents RCE via settings.json)
-    const { key, source } = getAnthropicApiKeyWithSource({
-      skipRetrievingKeyFromApiKeyHelper: true,
-    })
-    // If apiKeyHelper is configured, we have a key source even though we
-    // haven't executed it yet - return 'loading' to indicate we'll verify later
-    if (key || source === 'apiKeyHelper') {
-      return 'loading'
-    }
-    return 'missing'
-  })
-  const [error, setError] = useState<Error | null>(null)
-
-  const verify = useCallback(async (): Promise<void> => {
-    if (!isAnthropicAuthEnabled() || isClaudeAISubscriber()) {
-      setStatus('valid')
-      return
-    }
-    // Warm the apiKeyHelper cache (no-op if not configured), then read from
-    // all sources. getAnthropicApiKeyWithSource() reads the now-warm cache.
-    await getApiKeyFromApiKeyHelper(getIsNonInteractiveSession())
-    const { key: apiKey, source } = getAnthropicApiKeyWithSource()
-    if (!apiKey) {
-      if (source === 'apiKeyHelper') {
-        setStatus('error')
-        setError(new Error('API key helper did not return a valid key'))
-        return
-      }
-      const newStatus = 'missing'
-      setStatus(newStatus)
-      return
-    }
-
-    try {
-      const isValid = await verifyApiKey(apiKey, false)
-      const newStatus = isValid ? 'valid' : 'invalid'
-      setStatus(newStatus)
-      return
-    } catch (error) {
-      // This happens when there an error response from the API but it's not an invalid API key error
-      // In this case, we still mark the API key as invalid - but we also log the error so we can
-      // display it to the user to be more helpful
-      setError(error as Error)
-      const newStatus = 'error'
-      setStatus(newStatus)
-      return
-    }
-  }, [])
-
-  return {
-    status,
-    reverify: verify,
-    error,
-  }
-}