@pkgseer/cli 0.3.0 → 0.4.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   version
-} from "./shared/chunk-9yar14cw.js";
+} from "./shared/chunk-c1e7ntb6.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -24,6 +24,7 @@ var CliPackageInfoDocument = gql`
       homepage
       repositoryUrl
       downloadsLastMonth
+      downloadsTotal
     }
     security {
       vulnerabilityCount
@@ -106,6 +107,7 @@ var CliComparePackagesDocument = gql`
       version
       license
       downloadsLastMonth
+      downloadsTotal
       vulnerabilityCount
       quality {
         score
@@ -234,6 +236,7 @@ var CombinedSearchDocument = gql`
         registry
         score
         snippet
+        matchLine
         filePath
         startLine
         endLine
@@ -261,6 +264,56 @@ var CombinedSearchDocument = gql`
   }
 }
     `;
+var SearchProgressDocument = gql`
+    query SearchProgress($searchRef: String!, $includeResults: Boolean) {
+  searchProgress(searchRef: $searchRef, includeResults: $includeResults) {
+    searchRef
+    status
+    packagesTotal
+    packagesReady
+    elapsedMs
+    query
+    mode
+    expiresAt
+  }
+}
+    `;
+var SearchResultsDocument = gql`
+    query SearchResults($searchRef: String!) {
+  searchResults(searchRef: $searchRef) {
+    query
+    mode
+    totalResults
+    entries {
+      id
+      type
+      title
+      subtitle
+      packageName
+      registry
+      score
+      snippet
+      matchLine
+      filePath
+      startLine
+      endLine
+      language
+      chunkType
+      repoUrl
+      gitRef
+      pageId
+      sourceUrl
+    }
+    indexingStatus {
+      registry
+      packageName
+      version
+      codeStatus
+      docsStatus
+    }
+  }
+}
+    `;
 var FetchCodeContextDocument = gql`
     query FetchCodeContext($repoUrl: String!, $gitRef: String!, $filePath: String!, $startLine: Int, $endLine: Int) {
   fetchCodeContext(
@@ -297,6 +350,14 @@ var CliDocsGetDocument = gql`
   }
 }
     `;
+var TriggerIndexingDocument = gql`
+    mutation TriggerIndexing($input: TriggerIndexingInput!) {
+  triggerIndexing(input: $input) {
+    accepted
+    skipped
+  }
+}
+    `;
 var CreateProjectDocument = gql`
     mutation CreateProject($input: CreateProjectInput!) {
   createProject(input: $input) {
@@ -326,6 +387,7 @@ var PackageSummaryDocument = gql`
       repositoryUrl
       license
       downloadsLastMonth
+      downloadsTotal
       downloadsRefreshedAt
     }
     security {
@@ -468,6 +530,7 @@ var ComparePackagesDocument = gql`
       latestVersion
       license
       downloadsLastMonth
+      downloadsTotal
       vulnerabilityCount
       quality {
         score
@@ -591,6 +654,237 @@ var SearchPackageDocsDocument = gql`
   }
 }
     `;
+var FindSymbolDocument = gql`
+    query FindSymbol($registry: Registry!, $packageName: String!, $name: String, $namespace: String, $kind: SymbolKind, $publicOnly: Boolean, $version: String, $includeCode: Boolean, $contextLines: Int, $mode: NavigationMode, $waitTimeoutMs: Int) {
+  findSymbol(
+    registry: $registry
+    packageName: $packageName
+    name: $name
+    namespace: $namespace
+    kind: $kind
+    publicOnly: $publicOnly
+    version: $version
+    includeCode: $includeCode
+    contextLines: $contextLines
+    mode: $mode
+    waitTimeoutMs: $waitTimeoutMs
+  ) {
+    symbols {
+      symbolId
+      name
+      qualifiedPath
+      kind
+      arity
+      isPublic
+      filePath
+      startLine
+      endLine
+      code
+      callerCount
+    }
+    totalMatches
+    hasMore
+    indexedVersion
+  }
+}
+    `;
+var SearchSymbolsDocument = gql`
+    query SearchSymbols($registry: Registry!, $packageName: String!, $query: String!, $kind: SymbolKind, $version: String, $limit: Int, $mode: NavigationMode, $waitTimeoutMs: Int) {
+  searchSymbols(
+    registry: $registry
+    packageName: $packageName
+    query: $query
+    kind: $kind
+    version: $version
+    limit: $limit
+    mode: $mode
+    waitTimeoutMs: $waitTimeoutMs
+  ) {
+    results {
+      name
+      chunkType
+      filePath
+      startLine
+      endLine
+      preview
+      contentPreview
+      language
+    }
+    totalMatches
+    hasMore
+    indexedVersion
+  }
+}
+    `;
+var ListSymbolsDocument = gql`
+    query ListSymbols($registry: Registry!, $packageName: String!, $scope: ListScope!, $filePath: String, $namespace: String, $publicOnly: Boolean, $includePopularity: Boolean, $limit: Int, $version: String, $mode: NavigationMode, $waitTimeoutMs: Int) {
+  listSymbols(
+    registry: $registry
+    packageName: $packageName
+    scope: $scope
+    filePath: $filePath
+    namespace: $namespace
+    publicOnly: $publicOnly
+    includePopularity: $includePopularity
+    limit: $limit
+    version: $version
+    mode: $mode
+    waitTimeoutMs: $waitTimeoutMs
+  ) {
+    symbols {
+      symbolId
+      name
+      qualifiedPath
+      kind
+      arity
+      isPublic
+      filePath
+      startLine
+      endLine
+      callerCount
+    }
+    namespaces
+    total
+    hasMore
+    file {
+      path
+      language
+    }
+    error
+  }
+}
+    `;
+var SymbolDependenciesDocument = gql`
+    query SymbolDependencies($symbol: SymbolReferenceInput!, $maxDepth: Int, $maxResults: Int, $includeExternal: Boolean, $includeBuiltins: Boolean, $mode: NavigationMode, $waitTimeoutMs: Int) {
+  symbolDependencies(
+    symbol: $symbol
+    maxDepth: $maxDepth
+    maxResults: $maxResults
+    includeExternal: $includeExternal
+    includeBuiltins: $includeBuiltins
+    mode: $mode
+    waitTimeoutMs: $waitTimeoutMs
+  ) {
+    root {
+      symbolId
+      name
+      qualifiedPath
+    }
+    dependencies {
+      symbolId
+      name
+      qualifiedPath
+      kind
+      filePath
+      callLine
+      isExternal
+      depth
+      package {
+        registry
+        name
+      }
+    }
+    externalPackages
+    builtinCalls
+    missingPackages
+    total
+    hasMore
+  }
+}
+    `;
+var SymbolDependentsDocument = gql`
+    query SymbolDependents($symbol: SymbolReferenceInput!, $samePackageOnly: Boolean, $maxResults: Int, $mode: NavigationMode, $waitTimeoutMs: Int) {
+  symbolDependents(
+    symbol: $symbol
+    samePackageOnly: $samePackageOnly
+    maxResults: $maxResults
+    mode: $mode
+    waitTimeoutMs: $waitTimeoutMs
+  ) {
+    target {
+      symbolId
+      name
+      qualifiedPath
+    }
+    dependents {
+      symbolId
+      name
+      qualifiedPath
+      kind
+      isPublic
+      filePath
+      callLine
+    }
+    total
+    hasMore
+  }
+}
+    `;
+var PackageImportsDocument = gql`
+    query PackageImports($registry: Registry!, $packageName: String!, $filePath: String, $resolvedOnly: Boolean, $limit: Int, $version: String, $mode: NavigationMode, $waitTimeoutMs: Int) {
+  packageImports(
+    registry: $registry
+    packageName: $packageName
+    filePath: $filePath
+    resolvedOnly: $resolvedOnly
+    limit: $limit
+    version: $version
+    mode: $mode
+    waitTimeoutMs: $waitTimeoutMs
+  ) {
+    imports {
+      sourcePath
+      imported
+      alias
+      kind
+      filePath
+      line
+      isGlob
+      typeOnly
+      package
+      resolvedPackage {
+        registry
+        name
+      }
+    }
+    uniqueDependencies
+    unresolvedCount
+  }
+}
+    `;
+var CallPathDocument = gql`
+    query CallPath($from: SymbolReferenceInput!, $to: SymbolReferenceInput!, $maxDepth: Int, $mode: NavigationMode, $waitTimeoutMs: Int) {
+  callPath(
+    from: $from
+    to: $to
+    maxDepth: $maxDepth
+    mode: $mode
+    waitTimeoutMs: $waitTimeoutMs
+  ) {
+    pathFound
+    fromSymbol {
+      symbolId
+      name
+      qualifiedPath
+    }
+    toSymbol {
+      symbolId
+      name
+      qualifiedPath
+    }
+    paths {
+      length
+      hops {
+        symbolId
+        name
+        qualifiedPath
+        filePath
+        callLine
+      }
+    }
+  }
+}
+    `;
 var SearchProjectDocsDocument = gql`
     query SearchProjectDocs($project: String!, $keywords: [String!], $matchMode: MatchMode, $includeSnippets: Boolean, $limit: Int) {
   searchProjectDocs(
@@ -629,8 +923,11 @@ var CliDocsSearchDocumentString = print(CliDocsSearchDocument);
 var CliProjectDocsSearchDocumentString = print(CliProjectDocsSearchDocument);
 var CliDocsListDocumentString = print(CliDocsListDocument);
 var CombinedSearchDocumentString = print(CombinedSearchDocument);
+var SearchProgressDocumentString = print(SearchProgressDocument);
+var SearchResultsDocumentString = print(SearchResultsDocument);
 var FetchCodeContextDocumentString = print(FetchCodeContextDocument);
 var CliDocsGetDocumentString = print(CliDocsGetDocument);
+var TriggerIndexingDocumentString = print(TriggerIndexingDocument);
 var CreateProjectDocumentString = print(CreateProjectDocument);
 var PackageSummaryDocumentString = print(PackageSummaryDocument);
 var PackageVulnerabilitiesDocumentString = print(PackageVulnerabilitiesDocument);
@@ -641,6 +938,13 @@ var ListPackageDocsDocumentString = print(ListPackageDocsDocument);
 var FetchPackageDocDocumentString = print(FetchPackageDocDocument);
 var GetDocPageDocumentString = print(GetDocPageDocument);
 var SearchPackageDocsDocumentString = print(SearchPackageDocsDocument);
+var FindSymbolDocumentString = print(FindSymbolDocument);
+var SearchSymbolsDocumentString = print(SearchSymbolsDocument);
+var ListSymbolsDocumentString = print(ListSymbolsDocument);
+var SymbolDependenciesDocumentString = print(SymbolDependenciesDocument);
+var SymbolDependentsDocumentString = print(SymbolDependentsDocument);
+var PackageImportsDocumentString = print(PackageImportsDocument);
+var CallPathDocumentString = print(CallPathDocument);
 var SearchProjectDocsDocumentString = print(SearchProjectDocsDocument);
 function getSdk(client, withWrapper = defaultWrapper) {
   return {
@@ -671,12 +975,21 @@ function getSdk(client, withWrapper = defaultWrapper) {
     CombinedSearch(variables, requestHeaders) {
       return withWrapper((wrappedRequestHeaders) => client.rawRequest(CombinedSearchDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "CombinedSearch", "query", variables);
     },
+    SearchProgress(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(SearchProgressDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "SearchProgress", "query", variables);
+    },
+    SearchResults(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(SearchResultsDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "SearchResults", "query", variables);
+    },
     FetchCodeContext(variables, requestHeaders) {
       return withWrapper((wrappedRequestHeaders) => client.rawRequest(FetchCodeContextDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "FetchCodeContext", "query", variables);
     },
     CliDocsGet(variables, requestHeaders) {
       return withWrapper((wrappedRequestHeaders) => client.rawRequest(CliDocsGetDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "CliDocsGet", "query", variables);
     },
+    TriggerIndexing(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(TriggerIndexingDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "TriggerIndexing", "mutation", variables);
+    },
     CreateProject(variables, requestHeaders) {
       return withWrapper((wrappedRequestHeaders) => client.rawRequest(CreateProjectDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "CreateProject", "mutation", variables);
     },
@@ -707,6 +1020,27 @@ function getSdk(client, withWrapper = defaultWrapper) {
     SearchPackageDocs(variables, requestHeaders) {
       return withWrapper((wrappedRequestHeaders) => client.rawRequest(SearchPackageDocsDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "SearchPackageDocs", "query", variables);
     },
+    FindSymbol(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(FindSymbolDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "FindSymbol", "query", variables);
+    },
+    SearchSymbols(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(SearchSymbolsDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "SearchSymbols", "query", variables);
+    },
+    ListSymbols(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(ListSymbolsDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "ListSymbols", "query", variables);
+    },
+    SymbolDependencies(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(SymbolDependenciesDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "SymbolDependencies", "query", variables);
+    },
+    SymbolDependents(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(SymbolDependentsDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "SymbolDependents", "query", variables);
+    },
+    PackageImports(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(PackageImportsDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "PackageImports", "query", variables);
+    },
+    CallPath(variables, requestHeaders) {
+      return withWrapper((wrappedRequestHeaders) => client.rawRequest(CallPathDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "CallPath", "query", variables);
+    },
     SearchProjectDocs(variables, requestHeaders) {
       return withWrapper((wrappedRequestHeaders) => client.rawRequest(SearchProjectDocsDocumentString, variables, { ...requestHeaders, ...wrappedRequestHeaders }), "SearchProjectDocs", "query", variables);
     }
@@ -1037,8 +1371,17 @@ var TOOL_NAMES = [
   "list_package_docs",
   "fetch_package_doc",
   "search",
+  "search_status",
   "fetch_code_context",
-  "search_project_docs"
+  "search_project_docs",
+  "find_symbol",
+  "search_symbols",
+  "list_symbols",
+  "symbol_callers",
+  "symbol_callees",
+  "package_imports",
+  "call_path",
+  "trigger_indexing"
 ];
 var ToolNameSchema = z.enum(TOOL_NAMES);
 var SharedConfigFields = {
@@ -1440,6 +1783,17 @@ class PkgseerServiceImpl {
     });
     return { data: result.data, errors: result.errors };
   }
+  async getSearchProgress(searchRef, options) {
+    const result = await this.client.SearchProgress({
+      searchRef,
+      includeResults: options?.includeResults
+    });
+    return { data: result.data, errors: result.errors };
+  }
+  async getSearchResults(searchRef) {
+    const result = await this.client.SearchResults({ searchRef });
+    return { data: result.data, errors: result.errors };
+  }
   async fetchCodeContext(repoUrl, gitRef, filePath, options) {
     const result = await this.client.FetchCodeContext({
       repoUrl,
@@ -1450,6 +1804,100 @@ class PkgseerServiceImpl {
     });
     return { data: result.data, errors: result.errors };
   }
+  async findSymbol(registry, packageName, options) {
+    const result = await this.client.FindSymbol({
+      registry,
+      packageName,
+      name: options?.name,
+      namespace: options?.namespace,
+      kind: options?.kind,
+      publicOnly: options?.publicOnly,
+      version: options?.version,
+      includeCode: options?.includeCode,
+      contextLines: options?.contextLines,
+      mode: options?.mode,
+      waitTimeoutMs: options?.waitTimeoutMs
+    });
+    return { data: result.data, errors: result.errors };
+  }
+  async searchSymbols(registry, packageName, query, options) {
+    const result = await this.client.SearchSymbols({
+      registry,
+      packageName,
+      query,
+      kind: options?.kind,
+      version: options?.version,
+      limit: options?.limit,
+      mode: options?.mode,
+      waitTimeoutMs: options?.waitTimeoutMs
+    });
+    return { data: result.data, errors: result.errors };
+  }
+  async listSymbols(registry, packageName, scope, options) {
+    const result = await this.client.ListSymbols({
+      registry,
+      packageName,
+      scope,
+      filePath: options?.filePath,
+      namespace: options?.namespace,
+      publicOnly: options?.publicOnly,
+      includePopularity: options?.includePopularity,
+      limit: options?.limit,
+      version: options?.version,
+      mode: options?.mode,
+      waitTimeoutMs: options?.waitTimeoutMs
+    });
+    return { data: result.data, errors: result.errors };
+  }
+  async symbolDependencies(symbol, options) {
+    const result = await this.client.SymbolDependencies({
+      symbol,
+      maxDepth: options?.maxDepth,
+      maxResults: options?.maxResults,
+      includeExternal: options?.includeExternal,
+      includeBuiltins: options?.includeBuiltins,
+      mode: options?.mode,
+      waitTimeoutMs: options?.waitTimeoutMs
+    });
+    return { data: result.data, errors: result.errors };
+  }
+  async symbolDependents(symbol, options) {
+    const result = await this.client.SymbolDependents({
+      symbol,
+      samePackageOnly: options?.samePackageOnly,
+      maxResults: options?.maxResults,
+      mode: options?.mode,
+      waitTimeoutMs: options?.waitTimeoutMs
+    });
+    return { data: result.data, errors: result.errors };
+  }
+  async packageImports(registry, packageName, options) {
+    const result = await this.client.PackageImports({
+      registry,
+      packageName,
+      filePath: options?.filePath,
+      resolvedOnly: options?.resolvedOnly,
+      limit: options?.limit,
+      version: options?.version,
+      mode: options?.mode,
+      waitTimeoutMs: options?.waitTimeoutMs
+    });
+    return { data: result.data, errors: result.errors };
+  }
+  async callPath(from, to, options) {
+    const result = await this.client.CallPath({
+      from,
+      to,
+      maxDepth: options?.maxDepth,
+      mode: options?.mode,
+      waitTimeoutMs: options?.waitTimeoutMs
+    });
+    return { data: result.data, errors: result.errors };
+  }
+  async triggerIndexing(input) {
+    const result = await this.client.TriggerIndexing({ input });
+    return { data: result.data, errors: result.errors };
+  }
 }
 // src/services/project-service.ts
 var PROJECT_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
@@ -1747,58 +2195,6 @@ function registerAuthStatusCommand(program) {
   });
 }
 
-// src/commands/config-show.ts
-async function configShowAction(deps) {
-  const { configService } = deps;
-  const { config, globalPath, projectPath } = await configService.loadMergedConfig();
-  if (!globalPath && !projectPath) {
-    console.log(`No configuration found.
-`);
-    console.log("  Global config: ~/.pkgseer/config.yml");
-    console.log(`  Project config: pkgseer.yml
-`);
-    console.log("Create a config file to customize pkgseer behavior.");
-    return;
-  }
-  console.log(`Configuration sources:
-`);
-  if (globalPath) {
-    console.log(`  Global: ${globalPath}`);
-  }
-  if (projectPath) {
-    console.log(`  Project: ${projectPath}`);
-  }
-  console.log(`
-Merged configuration:
-`);
-  if (config.enabled_tools !== undefined) {
-    if (config.enabled_tools.length > 0) {
-      console.log("  enabled_tools:");
-      for (const tool of config.enabled_tools) {
-        console.log(`    - ${tool}`);
-      }
-    } else {
-      console.log("  enabled_tools: [] (no tools enabled)");
-    }
-  } else {
-    console.log("  enabled_tools: (all tools enabled by default)");
-  }
-  if (config.project) {
-    console.log(`  project: ${config.project}`);
-  }
-}
-var SHOW_DESCRIPTION = `Display current configuration.
-
-Shows the merged configuration from global (~/.pkgseer/config.yml) and
-project (pkgseer.yml) config files. Project config takes precedence
-over global config for overlapping settings.`;
-function registerConfigShowCommand(program) {
-  program.command("show").summary("Display current configuration").description(SHOW_DESCRIPTION).action(async () => {
-    const deps = await createContainer();
-    await configShowAction(deps);
-  });
-}
-
 // src/commands/shared.ts
 function parsePackageSpec(spec) {
   let registry = "npm";
@@ -1806,7 +2202,16 @@ function parsePackageSpec(spec) {
   if (spec.includes(":")) {
     const colonIndex = spec.indexOf(":");
     const potentialRegistry = spec.slice(0, colonIndex).toLowerCase();
-    if (["npm", "pypi", "hex", "crates"].includes(potentialRegistry)) {
+    if ([
+      "npm",
+      "pypi",
+      "hex",
+      "crates",
+      "nuget",
+      "maven",
+      "zig",
+      "vcpkg"
+    ].includes(potentialRegistry)) {
       registry = potentialRegistry;
       rest = spec.slice(colonIndex + 1);
     }
@@ -1826,7 +2231,11 @@ function toGraphQLRegistry(registry) {
     npm: "NPM",
     pypi: "PYPI",
     hex: "HEX",
-    crates: "CRATES"
+    crates: "CRATES",
+    nuget: "NUGET",
+    maven: "MAVEN",
+    zig: "ZIG",
+    vcpkg: "VCPKG"
   };
   return map[registry.toLowerCase()] || "NPM";
 }
@@ -1872,6 +2281,11 @@ function formatNumber(num) {
     return "N/A";
   return num.toLocaleString();
 }
+function truncate(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return `${text.slice(0, maxLength - 3)}...`;
+}
 function keyValueTable(pairs) {
   const maxKeyLen = Math.max(...pairs.map(([k]) => k.length));
   return pairs.map(([key, value]) => `  ${key.padEnd(maxKeyLen)}  ${value ?? "N/A"}`).join(`
@@ -1970,24 +2384,630 @@ function formatScore(score) {
   return `${bar} ${percentage}%`;
 }
 
-// src/commands/docs/get.ts
-function parsePackageRef(ref) {
-  if (!ref.includes("/")) {
+// src/commands/code/shared.ts
+function parseSymbolRef(spec) {
+  const hashIndex = spec.indexOf("#");
+  if (hashIndex >= 0) {
+    const packagePart = spec.slice(0, hashIndex);
+    const symbolName = spec.slice(hashIndex + 1);
+    const parsed2 = parsePackageSpec(packagePart);
     return {
-      pageId: ref,
-      originalRef: ref,
-      isGlobalId: true
+      registry: toGraphQLRegistry(parsed2.registry),
+      packageName: parsed2.name,
+      symbolName: symbolName || undefined
     };
   }
-  const parts = ref.split("/");
-  if (parts.length < 2) {
-    throw new Error(`Invalid format: "${ref}". Expected at least 2 parts separated by "/"`);
+  const parsed = parsePackageSpec(spec);
+  return {
+    registry: toGraphQLRegistry(parsed.registry),
+    packageName: parsed.name
+  };
+}
+function buildSymbolReference(spec, id) {
+  if (id) {
+    return { symbolId: Number.parseInt(id, 10) };
   }
-  if (parts.length >= 4) {
-    const registry = parts[0];
-    const packageName2 = parts[1];
-    const version2 = parts[2];
-    const pageId2 = parts.slice(3).join("/");
+  if (!spec) {
+    throw new Error("Symbol reference required. Use registry:package#symbolName or --id <number>");
+  }
+  return parseSymbolRef(spec);
+}
+function parseIntOption(value, name) {
+  if (value === undefined)
+    return;
+  const n = Number.parseInt(value, 10);
+  if (Number.isNaN(n) || n < 0) {
+    throw new Error(`${name} must be a non-negative integer`);
+  }
+  return n;
+}
+function parseWaitTimeout(wait) {
+  if (wait === undefined)
+    return;
+  const ms = Number.parseInt(wait, 10);
+  if (Number.isNaN(ms) || ms < 0 || ms > 30000) {
+    throw new Error("--wait must be a number between 0 and 30000");
+  }
+  return ms;
+}
+function parseNavigationMode(mode) {
+  if (!mode)
+    return;
+  const upper = mode.toUpperCase();
+  if (upper === "SUMMARY" || upper === "DETAILED")
+    return upper;
+  throw new Error("--mode must be 'summary' or 'detailed'");
+}
+function formatSymbol(symbol) {
+  const parts = [];
+  const kindLabel = symbol.kind ? `[${symbol.kind}]` : "";
+  const visibility = symbol.isPublic === false ? "(private) " : "";
+  const arity = symbol.arity != null ? `/${symbol.arity}` : "";
+  parts.push(`${kindLabel} ${visibility}${symbol.name}${arity}`.trim());
+  if (symbol.qualifiedPath && symbol.qualifiedPath !== symbol.name) {
+    parts.push(`  Path: ${symbol.qualifiedPath}`);
+  }
+  if (symbol.filePath) {
+    const loc = symbol.startLine ? `${symbol.filePath}:${symbol.startLine}` : symbol.filePath;
+    parts.push(`  File: ${loc}`);
+  }
+  const meta = [`id:${symbol.symbolId}`];
+  if (symbol.callerCount != null) {
+    meta.push(`callers:${symbol.callerCount}`);
+  }
+  parts.push(`  ${meta.join("  ")}`);
+  if (symbol.code) {
+    parts.push("");
+    parts.push(symbol.code.split(`
+`).map((line) => `  ${line}`).join(`
+`));
+  }
+  return parts.join(`
+`);
+}
+function formatDependencyEntry(entry) {
+  const parts = [];
+  const kindLabel = entry.kind ? `[${entry.kind}]` : "";
+  const depthLabel = entry.depth ? ` (depth:${entry.depth})` : "";
+  const extLabel = entry.isExternal ? " [external]" : "";
+  parts.push(`${kindLabel} ${entry.name}${depthLabel}${extLabel}`.trim());
+  if (entry.qualifiedPath && entry.qualifiedPath !== entry.name) {
+    parts.push(`  Path: ${entry.qualifiedPath}`);
+  }
+  if (entry.filePath) {
+    const loc = entry.callLine ? `${entry.filePath}:${entry.callLine}` : entry.filePath;
+    parts.push(`  File: ${loc}`);
+  }
+  if (entry.package) {
+    parts.push(`  Package: ${entry.package.registry}:${entry.package.name}`);
+  }
+  if (entry.symbolId) {
+    parts.push(`  id:${entry.symbolId}`);
+  }
+  return parts.join(`
+`);
+}
+
+// src/commands/code/callees.ts
+function formatCalleesResult(data) {
+  const lines = [];
+  lines.push(`Callees of ${data.root.qualifiedPath ?? data.root.name} (id:${data.root.symbolId})`);
+  lines.push(`${data.total} callee(s)${data.hasMore ? " (more available)" : ""}`);
+  if (data.externalPackages && data.externalPackages.length > 0) {
+    lines.push(`External packages: ${data.externalPackages.join(", ")}`);
+  }
+  if (data.builtinCalls && data.builtinCalls.length > 0) {
+    const builtins = data.builtinCalls.filter(Boolean);
+    if (builtins.length > 0) {
+      lines.push(`Builtin calls: ${builtins.join(", ")}`);
+    }
+  }
+  lines.push("");
+  for (const dep of data.dependencies) {
+    lines.push(formatDependencyEntry(dep));
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+async function codeCalleesAction(symbolArg, options, deps) {
+  const { pkgseerService } = deps;
+  const symbolRef = buildSymbolReference(symbolArg, options.id);
+  const result = await pkgseerService.symbolDependencies(symbolRef, {
+    maxDepth: parseIntOption(options.maxDepth, "--max-depth"),
+    maxResults: parseIntOption(options.limit, "--limit"),
+    includeExternal: options.includeExternal,
+    includeBuiltins: options.includeBuiltins,
+    mode: parseNavigationMode(options.mode),
+    waitTimeoutMs: parseWaitTimeout(options.wait)
+  });
+  handleErrors(result.errors, options.json ?? false);
+  if (!result.data.symbolDependencies) {
+    outputError("Symbol not found. Verify the symbol reference or use --id.", options.json ?? false);
+    return;
+  }
+  if (options.json) {
+    output(result.data.symbolDependencies, true);
+  } else {
+    console.log(formatCalleesResult(result.data.symbolDependencies));
+  }
+}
+var CALLEES_DESCRIPTION = `Find what a symbol calls.
+
+Shows functions and methods that the specified symbol depends on.
+Use registry:package#symbolName format or --id for direct lookup.
+
+Examples:
+  pkgseer code callees npm:express#Router
+  pkgseer code callees --id 12345
+  pkgseer code callees npm:lodash#merge --max-depth 2 --include-external`;
+function registerCodeCalleesCommand(program) {
+  program.command("callees [symbol]").summary("Find what a symbol calls").description(CALLEES_DESCRIPTION).option("--id <id>", "Direct symbol ID").option("--max-depth <n>", "Max traversal depth").option("--limit <n>", "Max results").option("--include-external", "Include external package calls").option("--include-builtins", "Include builtin function calls").option("--mode <mode>", "Response detail: summary or detailed").option("--wait <ms>", "Max ms to wait for indexing (0-30000)").option("--json", "Output as JSON").action(async (symbolArg, options) => {
+    await withCliErrorHandling(options.json ?? false, async () => {
+      const deps = await createContainer();
+      await codeCalleesAction(symbolArg, options, deps);
+    });
+  });
+}
+// src/commands/code/callers.ts
+function formatCallersResult(data) {
+  const lines = [];
+  lines.push(`Callers of ${data.target.qualifiedPath ?? data.target.name} (id:${data.target.symbolId})`);
+  lines.push(`${data.total} caller(s)${data.hasMore ? " (more available)" : ""}`);
+  lines.push("");
+  for (const dep of data.dependents) {
+    lines.push(formatDependencyEntry(dep));
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+async function codeCallersAction(symbolArg, options, deps) {
+  const { pkgseerService } = deps;
+  const symbolRef = buildSymbolReference(symbolArg, options.id);
+  const result = await pkgseerService.symbolDependents(symbolRef, {
+    samePackageOnly: options.samePackageOnly,
+    maxResults: parseIntOption(options.limit, "--limit"),
+    mode: parseNavigationMode(options.mode),
+    waitTimeoutMs: parseWaitTimeout(options.wait)
+  });
+  handleErrors(result.errors, options.json ?? false);
+  if (!result.data.symbolDependents) {
+    outputError("Symbol not found. Verify the symbol reference or use --id.", options.json ?? false);
+    return;
+  }
+  if (options.json) {
+    output(result.data.symbolDependents, true);
+  } else {
+    console.log(formatCallersResult(result.data.symbolDependents));
+  }
+}
+var CALLERS_DESCRIPTION = `Find what calls a symbol.
+
+Shows functions and methods that call the specified symbol.
+Use registry:package#symbolName format or --id for direct lookup.
+
+Examples:
+  pkgseer code callers npm:express#Router
+  pkgseer code callers --id 12345
+  pkgseer code callers npm:lodash#debounce --same-package-only`;
+function registerCodeCallersCommand(program) {
+  program.command("callers [symbol]").summary("Find what calls a symbol").description(CALLERS_DESCRIPTION).option("--id <id>", "Direct symbol ID").option("--same-package-only", "Only show callers from the same package").option("--limit <n>", "Max results").option("--mode <mode>", "Response detail: summary or detailed").option("--wait <ms>", "Max ms to wait for indexing (0-30000)").option("--json", "Output as JSON").action(async (symbolArg, options) => {
+    await withCliErrorHandling(options.json ?? false, async () => {
+      const deps = await createContainer();
+      await codeCallersAction(symbolArg, options, deps);
+    });
+  });
+}
+// src/commands/code/find.ts
+function formatFindResult(data) {
+  const lines = [];
+  lines.push(`Found ${data.totalMatches} symbol(s)${data.hasMore ? " (more available)" : ""}`);
+  if (data.indexedVersion) {
+    lines.push(`Indexed version: ${data.indexedVersion}`);
+  }
+  lines.push("");
+  for (const symbol of data.symbols) {
+    lines.push(formatSymbol(symbol));
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+async function codeFindAction(packageArg, nameArg, options, deps) {
+  const { pkgseerService } = deps;
+  const parsed = parsePackageSpec(packageArg);
+  const registry = toGraphQLRegistry(parsed.registry);
+  const result = await pkgseerService.findSymbol(registry, parsed.name, {
+    name: nameArg,
+    namespace: options.namespace,
+    kind: options.kind?.toUpperCase(),
+    publicOnly: options.publicOnly,
+    version: parsed.version,
+    includeCode: options.includeCode,
+    contextLines: parseIntOption(options.contextLines, "--context-lines"),
+    mode: parseNavigationMode(options.mode),
+    waitTimeoutMs: parseWaitTimeout(options.wait)
+  });
+  handleErrors(result.errors, options.json ?? false);
+  if (!result.data.findSymbol) {
+    outputError(`Package not found: ${parsed.name} in ${parsed.registry}`, options.json ?? false);
+    return;
+  }
+  if (options.json) {
+    output(result.data.findSymbol, true);
+  } else {
+    console.log(formatFindResult(result.data.findSymbol));
+  }
+}
+var FIND_DESCRIPTION = `Find symbols (functions, classes, modules) by name.
+
+Searches for symbols in a package by exact or partial name match.
+Returns symbol metadata, location, and optionally source code.
+
+Examples:
+  pkgseer code find npm:express Router
+  pkgseer code find pypi:requests get --kind function
+  pkgseer code find npm:lodash --namespace array --public-only
+  pkgseer code find npm:express Router --include-code`;
+function registerCodeFindCommand(program) {
+  program.command("find <package> [name]").summary("Find symbols by name").description(FIND_DESCRIPTION).option("--namespace <ns>", "Filter by namespace").option("--kind <kind>", "Filter by symbol kind (function, class, module, etc.)").option("--public-only", "Only show public symbols").option("--include-code", "Include source code in results").option("--context-lines <n>", "Lines of context around code").option("--mode <mode>", "Response detail: summary or detailed").option("--wait <ms>", "Max ms to wait for indexing (0-30000)").option("--json", "Output as JSON").action(async (packageArg, nameArg, options) => {
+    await withCliErrorHandling(options.json ?? false, async () => {
+      const deps = await createContainer();
+      await codeFindAction(packageArg, nameArg, options, deps);
+    });
+  });
+}
+// src/commands/code/imports.ts
+function formatImport(entry) {
+  const parts = [];
+  const kindLabel = entry.kind ? `[${entry.kind}]` : "";
+  const typeLabel = entry.typeOnly ? " (type)" : "";
+  const aliasLabel = entry.alias ? ` as ${entry.alias}` : "";
+  const imported = entry.imported ?? "*";
+  parts.push(`${kindLabel} ${imported}${aliasLabel}${typeLabel}`.trim());
+  if (entry.sourcePath) {
+    parts.push(`  from: ${entry.sourcePath}`);
+  }
+  if (entry.filePath) {
+    const loc = entry.line ? `${entry.filePath}:${entry.line}` : entry.filePath;
+    parts.push(`  File: ${loc}`);
+  }
+  if (entry.resolvedPackage) {
+    parts.push(`  Resolves to: ${entry.resolvedPackage.registry}:${entry.resolvedPackage.name}`);
+  } else if (entry.package) {
+    parts.push(`  Package: ${entry.package}`);
+  }
+  return parts.join(`
+`);
+}
+function formatImportsResult(data) {
+  const lines = [];
+  lines.push(`${data.imports.length} import(s)`);
+  if (data.uniqueDependencies && data.uniqueDependencies.length > 0) {
+    lines.push(`Unique dependencies: ${data.uniqueDependencies.join(", ")}`);
+  }
+  if (data.unresolvedCount != null && data.unresolvedCount > 0) {
+    lines.push(`Unresolved: ${data.unresolvedCount}`);
+  }
+  lines.push("");
+  for (const entry of data.imports) {
+    lines.push(formatImport(entry));
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+async function codeImportsAction(packageArg, options, deps) {
+  const { pkgseerService } = deps;
+  const parsed = parsePackageSpec(packageArg);
+  const registry = toGraphQLRegistry(parsed.registry);
+  const result = await pkgseerService.packageImports(registry, parsed.name, {
+    filePath: options.file,
+    resolvedOnly: options.resolvedOnly,
+    limit: parseIntOption(options.limit, "--limit"),
+    version: parsed.version,
+    mode: parseNavigationMode(options.mode),
+    waitTimeoutMs: parseWaitTimeout(options.wait)
+  });
+  handleErrors(result.errors, options.json ?? false);
+  if (!result.data.packageImports) {
+    outputError(`Package not found: ${parsed.name} in ${parsed.registry}`, options.json ?? false);
+    return;
+  }
+  if (options.json) {
+    output(result.data.packageImports, true);
+  } else {
+    console.log(formatImportsResult(result.data.packageImports));
+  }
+}
+var IMPORTS_DESCRIPTION = `List import statements in a package.
+
+Shows what a package imports, including source paths, resolved packages,
+and import types. Useful for understanding package dependencies at code level.
+
+Examples:
+  pkgseer code imports npm:express
+  pkgseer code imports npm:lodash --file src/index.js
+  pkgseer code imports pypi:requests --resolved-only`;
+function registerCodeImportsCommand(program) {
+  program.command("imports <package>").summary("List package import statements").description(IMPORTS_DESCRIPTION).option("--file <path>", "Filter by source file path").option("--resolved-only", "Only show resolved imports").option("--limit <n>", "Max results").option("--mode <mode>", "Response detail: summary or detailed").option("--wait <ms>", "Max ms to wait for indexing (0-30000)").option("--json", "Output as JSON").action(async (packageArg, options) => {
+    await withCliErrorHandling(options.json ?? false, async () => {
+      const deps = await createContainer();
+      await codeImportsAction(packageArg, options, deps);
+    });
+  });
+}
+// src/commands/code/list.ts
+function formatListResult(data) {
+  const lines = [];
+  lines.push(`${data.total} symbol(s)${data.hasMore ? " (more available)" : ""}`);
+  if (data.namespaces && data.namespaces.length > 0) {
+    lines.push(`Namespaces: ${data.namespaces.join(", ")}`);
+  }
+  if (data.file) {
+    lines.push(`File: ${data.file.path}${data.file.language ? ` (${data.file.language})` : ""}`);
+  }
+  if (data.error) {
+    lines.push(`Warning: ${data.error}`);
+  }
+  lines.push("");
+  for (const symbol of data.symbols) {
+    lines.push(formatSymbol(symbol));
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+async function codeListAction(packageArg, options, deps) {
+  const { pkgseerService } = deps;
+  const parsed = parsePackageSpec(packageArg);
+  const registry = toGraphQLRegistry(parsed.registry);
+  const scope = options.scope?.toUpperCase() ?? "EXPORTS";
+  if (scope !== "EXPORTS" && scope !== "FILE") {
+    outputError("--scope must be 'exports' or 'file'", options.json ?? false);
+    return;
+  }
+  if (scope === "FILE" && !options.file) {
+    outputError("--file is required when --scope is 'file'", options.json ?? false);
+    return;
+  }
+  const result = await pkgseerService.listSymbols(registry, parsed.name, scope, {
+    filePath: options.file,
+    namespace: options.namespace,
+    publicOnly: options.publicOnly,
+    includePopularity: options.includePopularity,
+    limit: parseIntOption(options.limit, "--limit"),
+    version: parsed.version,
+    mode: parseNavigationMode(options.mode),
+    waitTimeoutMs: parseWaitTimeout(options.wait)
+  });
+  handleErrors(result.errors, options.json ?? false);
+  if (!result.data.listSymbols) {
+    outputError(`Package not found: ${parsed.name} in ${parsed.registry}`, options.json ?? false);
+    return;
+  }
+  if (options.json) {
+    output(result.data.listSymbols, true);
+  } else {
+    console.log(formatListResult(result.data.listSymbols));
+  }
+}
+var LIST_DESCRIPTION = `Browse symbols in a package.
+
+Lists public exports (default) or file contents. Returns symbol names,
+types, locations, and optionally popularity data.
+
+Examples:
+  pkgseer code list npm:express
+  pkgseer code list npm:lodash --namespace array
+  pkgseer code list npm:express --scope file --file src/router.js
+  pkgseer code list pypi:requests --include-popularity`;
+function registerCodeListCommand(program) {
+  program.command("list <package>").summary("Browse symbols in a package").description(LIST_DESCRIPTION).option("--scope <scope>", "Scope: exports (default) or file").option("--file <path>", "File path (required when scope=file)").option("--namespace <ns>", "Filter by namespace").option("--public-only", "Only show public symbols").option("--include-popularity", "Include popularity data").option("--limit <n>", "Max results").option("--mode <mode>", "Response detail: summary or detailed").option("--wait <ms>", "Max ms to wait for indexing (0-30000)").option("--json", "Output as JSON").action(async (packageArg, options) => {
+    await withCliErrorHandling(options.json ?? false, async () => {
+      const deps = await createContainer();
+      await codeListAction(packageArg, options, deps);
+    });
+  });
+}
+// src/commands/code/path.ts
+function formatPathResult(data) {
+  const lines = [];
+  const fromName = data.fromSymbol.qualifiedPath ?? data.fromSymbol.name;
+  const toName = data.toSymbol.qualifiedPath ?? data.toSymbol.name;
+  lines.push(`Call path: ${fromName} -> ${toName}`);
+  if (!data.pathFound) {
+    lines.push("No path found between these symbols.");
+    return lines.join(`
+`);
+  }
+  lines.push(`${data.paths.length} path(s) found`);
+  lines.push("");
+  for (const [i, callPath] of data.paths.entries()) {
+    lines.push(`Path ${i + 1} (${callPath.length} hop${callPath.length !== 1 ? "s" : ""}):`);
+    for (const [j, hop] of callPath.hops.entries()) {
+      const name = hop.qualifiedPath ?? hop.name ?? "unknown";
+      const loc = hop.filePath ? hop.callLine ? ` ${hop.filePath}:${hop.callLine}` : ` ${hop.filePath}` : "";
+      const idPart = hop.symbolId ? ` (id:${hop.symbolId})` : "";
+      const arrow = j < callPath.hops.length - 1 ? " ->" : "";
+      lines.push(`  ${j + 1}. ${name}${idPart}${loc}${arrow}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+async function codePathAction(fromArg, toArg, options, deps) {
+  const { pkgseerService } = deps;
+  const fromRef = buildSymbolReference(fromArg, options.fromId);
+  const toRef = buildSymbolReference(toArg, options.toId);
+  const result = await pkgseerService.callPath(fromRef, toRef, {
+    maxDepth: parseIntOption(options.maxDepth, "--max-depth"),
+    mode: parseNavigationMode(options.mode),
+    waitTimeoutMs: parseWaitTimeout(options.wait)
+  });
+  handleErrors(result.errors, options.json ?? false);
+  if (!result.data.callPath) {
+    outputError("Could not find call path. Verify the symbol references.", options.json ?? false);
+    return;
+  }
+  if (options.json) {
+    output(result.data.callPath, true);
+  } else {
+    console.log(formatPathResult(result.data.callPath));
+  }
+}
+var PATH_DESCRIPTION = `Find call path between two symbols.
+
+Discovers the shortest call path from one symbol to another.
+Use registry:package#symbolName format or --from-id/--to-id for direct lookup.
+
+Examples:
+  pkgseer code path npm:express#app npm:express#Router
+  pkgseer code path --from-id 123 --to-id 456
+  pkgseer code path npm:lodash#merge npm:lodash#cloneDeep --max-depth 5`;
+function registerCodePathCommand(program) {
+  program.command("path [from] [to]").summary("Find call path between symbols").description(PATH_DESCRIPTION).option("--from-id <id>", "Source symbol ID").option("--to-id <id>", "Target symbol ID").option("--max-depth <n>", "Max path depth").option("--mode <mode>", "Response detail: summary or detailed").option("--wait <ms>", "Max ms to wait for indexing (0-30000)").option("--json", "Output as JSON").action(async (fromArg, toArg, options) => {
+    await withCliErrorHandling(options.json ?? false, async () => {
+      const deps = await createContainer();
+      await codePathAction(fromArg, toArg, options, deps);
+    });
+  });
+}
+// src/commands/code/search.ts
+function formatSearchResult(data) {
+  const lines = [];
+  lines.push(`${data.totalMatches} match(es)${data.hasMore ? " (more available)" : ""}`);
+  if (data.indexedVersion) {
+    lines.push(`Indexed version: ${data.indexedVersion}`);
+  }
+  lines.push("");
+  for (const entry of data.results) {
+    const kindLabel = entry.chunkType ? `[${entry.chunkType}]` : "";
+    const name = entry.name ?? "unnamed";
+    lines.push(`${kindLabel} ${name}`.trim());
+    if (entry.filePath) {
+      const loc = entry.startLine ? `${entry.filePath}:${entry.startLine}` : entry.filePath;
+      lines.push(`  File: ${loc}`);
+    }
+    if (entry.preview) {
+      lines.push(`  ${truncate(entry.preview, 200)}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+async function codeSearchAction(packageArg, query, options, deps) {
+  const { pkgseerService } = deps;
+  const parsed = parsePackageSpec(packageArg);
+  const registry = toGraphQLRegistry(parsed.registry);
+  const result = await pkgseerService.searchSymbols(registry, parsed.name, query, {
+    kind: options.kind?.toUpperCase(),
+    version: parsed.version,
+    limit: parseIntOption(options.limit, "--limit"),
+    mode: parseNavigationMode(options.mode),
+    waitTimeoutMs: parseWaitTimeout(options.wait)
+  });
+  handleErrors(result.errors, options.json ?? false);
+  if (!result.data.searchSymbols) {
+    outputError(`Package not found: ${parsed.name} in ${parsed.registry}`, options.json ?? false);
+    return;
+  }
+  if (options.json) {
+    output(result.data.searchSymbols, true);
+  } else {
+    console.log(formatSearchResult(result.data.searchSymbols));
+  }
+}
+var SEARCH_DESCRIPTION = `Full-text search within package code.
+
+Searches across functions, classes, modules, and doc sections.
+Returns matching code chunks with names, types, and previews.
+
+Examples:
+  pkgseer code search npm:express "middleware"
+  pkgseer code search pypi:requests "timeout" --kind function
+  pkgseer code search npm:lodash "deep clone" --limit 10`;
+function registerCodeSearchCommand(program) {
+  program.command("search <package> <query>").summary("Full-text search in package code").description(SEARCH_DESCRIPTION).option("--kind <kind>", "Filter by chunk type (function, class, module, etc.)").option("--limit <n>", "Max results (default: 25, max: 50)").option("--mode <mode>", "Response detail: summary or detailed").option("--wait <ms>", "Max ms to wait for indexing (0-30000)").option("--json", "Output as JSON").action(async (packageArg, query, options) => {
+    await withCliErrorHandling(options.json ?? false, async () => {
+      const deps = await createContainer();
+      await codeSearchAction(packageArg, query, options, deps);
+    });
+  });
+}
+// src/commands/config-show.ts
+async function configShowAction(deps) {
+  const { configService } = deps;
+  const { config, globalPath, projectPath } = await configService.loadMergedConfig();
+  if (!globalPath && !projectPath) {
+    console.log(`No configuration found.
+`);
+    console.log("  Global config: ~/.pkgseer/config.yml");
+    console.log(`  Project config: pkgseer.yml
+`);
+    console.log("Create a config file to customize pkgseer behavior.");
+    return;
+  }
+  console.log(`Configuration sources:
+`);
+  if (globalPath) {
+    console.log(`  Global: ${globalPath}`);
+  }
+  if (projectPath) {
+    console.log(`  Project: ${projectPath}`);
+  }
+  console.log(`
+Merged configuration:
+`);
+  if (config.enabled_tools !== undefined) {
+    if (config.enabled_tools.length > 0) {
+      console.log("  enabled_tools:");
+      for (const tool of config.enabled_tools) {
+        console.log(`    - ${tool}`);
+      }
+    } else {
+      console.log("  enabled_tools: [] (no tools enabled)");
+    }
+  } else {
+    console.log("  enabled_tools: (all tools enabled by default)");
+  }
+  if (config.project) {
+    console.log(`  project: ${config.project}`);
+  }
+}
+var SHOW_DESCRIPTION = `Display current configuration.
+
+Shows the merged configuration from global (~/.pkgseer/config.yml) and
+project (pkgseer.yml) config files. Project config takes precedence
+over global config for overlapping settings.`;
+function registerConfigShowCommand(program) {
+  program.command("show").summary("Display current configuration").description(SHOW_DESCRIPTION).action(async () => {
+    const deps = await createContainer();
+    await configShowAction(deps);
+  });
+}
+
+// src/commands/docs/get.ts
+function parsePackageRef(ref) {
+  if (!ref.includes("/")) {
+    return {
+      pageId: ref,
+      originalRef: ref,
+      isGlobalId: true
+    };
+  }
+  const parts = ref.split("/");
+  if (parts.length < 2) {
+    throw new Error(`Invalid format: "${ref}". Expected at least 2 parts separated by "/"`);
+  }
+  if (parts.length >= 4) {
+    const registry = parts[0];
+    const packageName2 = parts[1];
+    const version2 = parts[2];
+    const pageId2 = parts.slice(3).join("/");
     if (!registry || !packageName2 || !version2 || !pageId2) {
       throw new Error(`Invalid full form: "${ref}". All components (registry/package/version/document) are required.`);
     }
@@ -2338,7 +3358,7 @@ async function docsListAction(packageArg, options, deps) {
     console.log(formatDocsList(result.data.listPackageDocs));
   }
 }
-var LIST_DESCRIPTION = `List available documentation pages for a package.
+var LIST_DESCRIPTION2 = `List available documentation pages for a package.
 
 Shows all documentation pages with titles, globally unique page IDs,
 word counts, and descriptions. Use the page ID with 'docs get'
@@ -2351,15 +3371,66 @@ Examples:
   pkgseer docs list pypi:requests
   pkgseer docs list hex:phoenix@1.7.0 --json`;
 function registerDocsListCommand(program) {
-  program.command("list <package>").summary("List documentation pages").description(LIST_DESCRIPTION).option("-r, --registry <registry>", "Package registry", "npm").option("-V, --pkg-version <version>", "Package version").option("--json", "Output as JSON").action(async (packageName, options) => {
+  program.command("list <package>").summary("List documentation pages").description(LIST_DESCRIPTION2).option("-r, --registry <registry>", "Package registry", "npm").option("-V, --pkg-version <version>", "Package version").option("--json", "Output as JSON").action(async (packageName, options) => {
     await withCliErrorHandling(options.json ?? false, async () => {
       const deps = await createContainer();
       await docsListAction(packageName, options, deps);
     });
   });
 }
+// src/lib/polling.ts
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function pollUntilDone(config) {
+  const {
+    fetch: fetch2,
+    isDone,
+    onUpdate,
+    intervalMs,
+    maxWaitMs,
+    sleep = defaultSleep,
+    now = Date.now
+  } = config;
+  const startTime = now();
+  let lastData;
+  while (true) {
+    try {
+      const data = await fetch2();
+      lastData = data;
+      if (onUpdate) {
+        onUpdate(data);
+      }
+      if (isDone(data)) {
+        return { success: true, data };
+      }
+      const elapsed = now() - startTime;
+      if (elapsed >= maxWaitMs) {
+        return {
+          success: false,
+          error: `Client polling timeout after ${elapsed}ms`,
+          lastData
+        };
+      }
+      await sleep(intervalMs);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: `Poll failed: ${message}`,
+        lastData
+      };
+    }
+  }
+}
+
 // src/commands/search.ts
 var DEFAULT_WAIT_TIMEOUT_MS = 30000;
+var DEFAULT_POLL_INTERVAL_MS = 2000;
+var DEFAULT_MAX_POLL_TIME_MS = 120000;
+var TERMINAL_STATUSES = [
+  "COMPLETED",
+  "TIMEOUT",
+  "FAILED"
+];
 var colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -2575,7 +3646,7 @@ function abbrevLang(lang) {
   const lower = lang.toLowerCase();
   return LANG_ABBREV[lower] ?? lower;
 }
-function truncate(text, maxLen) {
+function truncate2(text, maxLen) {
   if (text.length <= maxLen)
     return text;
   return `${text.slice(0, maxLen - 3)}...`;
@@ -2629,9 +3700,9 @@ function formatEntryCompact(entry, useColors) {
   if (entry.snippet) {
     const bestLine = findBestSnippetLine(entry.snippet);
     if (bestLine) {
-      snippet = `  ${truncate(bestLine, 80)}`;
+      snippet = `  ${truncate2(bestLine, 80)}`;
       if (useColors) {
-        snippet = `  ${colors.dim}${truncate(bestLine, 80)}${colors.reset}`;
+        snippet = `  ${colors.dim}${truncate2(bestLine, 80)}${colors.reset}`;
       }
     }
   }
@@ -2737,24 +3808,138 @@ function formatSearchProgress(progress, searchRef, useColors) {
       lines.push(`Search ref: ${searchRef}`);
     }
   }
-  return lines.join(`
-`);
-}
-function getWaitTimeoutMs(options) {
-  if (options.noWait) {
-    return 0;
+  return lines.join(`
+`);
+}
+function getWaitTimeoutMs(options) {
+  if (options.noWait) {
+    return 0;
+  }
+  if (options.wait) {
+    const parsed = Number.parseInt(options.wait, 10);
+    if (!Number.isNaN(parsed) && parsed >= 0) {
+      return parsed;
+    }
+    console.warn(`Warning: Invalid --wait value "${options.wait}". Using default (${DEFAULT_WAIT_TIMEOUT_MS}ms).`);
+  }
+  return DEFAULT_WAIT_TIMEOUT_MS;
+}
+function shouldPoll(options) {
+  if (options.noPoll) {
+    return false;
+  }
+  return process.stdout.isTTY ?? false;
+}
+async function pollSearchProgress(searchRef, pkgseerService, useColors) {
+  const result = await pollUntilDone({
+    fetch: async () => {
+      const res = await pkgseerService.getSearchProgress(searchRef);
+      return res.data.searchProgress ?? null;
+    },
+    isDone: (progress) => {
+      if (!progress)
+        return true;
+      return TERMINAL_STATUSES.includes(progress.status);
+    },
+    onUpdate: (progress) => {
+      if (progress) {
+        const statusText = progress.status?.toLowerCase() ?? "unknown";
+        const ready = progress.packagesReady ?? 0;
+        const total = progress.packagesTotal ?? 0;
+        const elapsed = ((progress.elapsedMs ?? 0) / 1000).toFixed(1);
+        console.log(`  ${statusText} (${ready}/${total} ready) - ${elapsed}s`);
+      }
+    },
+    intervalMs: DEFAULT_POLL_INTERVAL_MS,
+    maxWaitMs: DEFAULT_MAX_POLL_TIME_MS
+  });
+  if (!result.success) {
+    return { success: false, error: result.error };
+  }
+  if (!result.data) {
+    return { success: false, error: "Search session not found" };
+  }
+  return { success: true, status: result.data.status };
+}
+async function handleResume(searchRef, pkgseerService, options, useColors) {
+  const progressResult = await pkgseerService.getSearchProgress(searchRef);
+  if (progressResult.errors?.length) {
+    handleErrors(progressResult.errors, options.json ?? false);
+    return true;
+  }
+  const progress = progressResult.data.searchProgress;
+  if (!progress) {
+    outputError("Search session not found. It may have expired (sessions last 1 hour).", options.json ?? false);
+    return true;
+  }
+  if (progress.status === "COMPLETED") {
+    const resultsResponse = await pkgseerService.getSearchResults(searchRef);
+    if (resultsResponse.errors?.length) {
+      handleErrors(resultsResponse.errors, options.json ?? false);
+      return true;
+    }
+    const searchResults = resultsResponse.data.searchResults;
+    if (!searchResults) {
+      outputError("Search completed but no results returned.", options.json ?? false);
+      return true;
+    }
+    outputResults(searchResults, options, useColors);
+    return true;
+  }
+  if (progress.status === "FAILED") {
+    outputError(`Search failed. Ref: ${searchRef}`, options.json ?? false);
+    return true;
+  }
+  if (progress.status === "TIMEOUT") {
+    outputError(`Search timed out. Try again or use --wait with a higher value.
+Ref: ${searchRef}`, options.json ?? false);
+    return true;
   }
-  if (options.wait) {
-    const parsed = Number.parseInt(options.wait, 10);
-    if (!Number.isNaN(parsed) && parsed >= 0) {
-      return parsed;
+  if (options.json) {
+    output({
+      completed: false,
+      searchRef,
+      progress: {
+        status: progress.status,
+        packagesTotal: progress.packagesTotal,
+        packagesReady: progress.packagesReady,
+        elapsedMs: progress.elapsedMs
+      },
+      message: "Search is still in progress."
+    }, true);
+    return true;
+  }
+  console.log("Checking search status...");
+  console.log(`Status: ${progress.status?.toLowerCase() ?? "unknown"}`);
+  if (shouldPoll(options)) {
+    console.log("Polling for completion...");
+    const pollResult = await pollSearchProgress(searchRef, pkgseerService, useColors);
+    if (!pollResult.success) {
+      outputError(pollResult.error, false);
+      console.log(`Resume with: pkgseer search --resume ${searchRef}`);
+      return true;
     }
-    console.warn(`Warning: Invalid --wait value "${options.wait}". Using default (${DEFAULT_WAIT_TIMEOUT_MS}ms).`);
+    if (pollResult.status === "COMPLETED") {
+      const resultsResponse = await pkgseerService.getSearchResults(searchRef);
+      if (resultsResponse.data.searchResults) {
+        outputResults(resultsResponse.data.searchResults, options, useColors);
+      }
+    } else {
+      console.log(`Search ended with status: ${pollResult.status.toLowerCase()}`);
+    }
+  } else {
+    console.log(`
+Resume with: pkgseer search --resume ${searchRef}`);
   }
-  return DEFAULT_WAIT_TIMEOUT_MS;
+  return true;
 }
 async function searchAction(queryArg, options, deps, defaultMode = "ALL") {
   const { pkgseerService } = deps;
+  const useColors = shouldUseColors(options.noColor);
+  if (options.resume?.trim()) {
+    await handleResume(options.resume.trim(), pkgseerService, options, useColors);
+    return;
+  }
   const query = Array.isArray(queryArg) ? queryArg.join(" ") : queryArg ?? "";
   if (!query.trim()) {
     outputError("Search query required. Provide query as argument.", options.json ?? false);
@@ -2771,7 +3956,6 @@ async function searchAction(queryArg, options, deps, defaultMode = "ALL") {
   const packages = parsePackageList(options.packages);
   const limit = options.limit ? Number.parseInt(options.limit, 10) : 25;
   const mode = options.mode ? toSearchMode(options.mode) : defaultMode;
-  const useColors = shouldUseColors(options.noColor);
   const waitTimeoutMs = getWaitTimeoutMs(options);
   const result = await pkgseerService.combinedSearch(packages, query, {
     mode,
@@ -2785,16 +3969,40 @@ async function searchAction(queryArg, options, deps, defaultMode = "ALL") {
     return;
   }
   if (!asyncResult.completed) {
+    const searchRef = asyncResult.searchRef;
     if (options.json) {
       output({
         completed: false,
-        searchRef: asyncResult.searchRef,
+        searchRef,
         progress: asyncResult.progress,
         message: "Search is still indexing. Retry for complete results."
       }, true);
-    } else {
-      console.log(formatSearchProgress(asyncResult.progress, asyncResult.searchRef, useColors));
+      return;
+    }
+    if (shouldPoll(options) && searchRef) {
+      console.log("Search in progress, polling for completion...");
+      const pollResult = await pollSearchProgress(searchRef, pkgseerService, useColors);
+      if (pollResult.success && pollResult.status === "COMPLETED") {
+        const resultsResponse = await pkgseerService.getSearchResults(searchRef);
+        if (resultsResponse.data.searchResults) {
+          console.log("");
+          outputResults(resultsResponse.data.searchResults, options, useColors);
+          return;
+        }
+      }
+      if (!pollResult.success) {
+        console.log(`
+${pollResult.error}`);
+      } else if (pollResult.status !== "COMPLETED") {
+        console.log(`
+Search ended with status: ${pollResult.status.toLowerCase()}`);
+      }
+      if (searchRef) {
+        console.log(`Resume with: pkgseer search --resume ${searchRef}`);
+      }
+      return;
     }
+    console.log(formatSearchProgress(asyncResult.progress, searchRef, useColors));
     return;
   }
   const searchResults = asyncResult.result;
@@ -2820,7 +4028,7 @@ function outputResults(results, options, useColors) {
     console.log(formatSearchResultsCompact(results, useColors));
   }
 }
-var SEARCH_DESCRIPTION = `Search code and documentation across packages.
+var SEARCH_DESCRIPTION2 = `Search code and documentation across packages.
 
 Searches both code (functions, classes) and documentation pages
 using the combined search endpoint. Returns results with snippets
@@ -2853,10 +4061,10 @@ Examples:
   # JSON output
   pkgseer search "error" -P express --json`;
 function addSearchOptions(cmd) {
-  return cmd.option("-P, --packages <packages>", "Packages to search (comma-separated). Format: name or registry/name[@version]. Examples: express | express,lodash | pypi/django@4.2").option("-m, --mode <mode>", "Search mode: all (default), code, docs").option("-l, --limit <n>", "Max results (default: 25)").option("-v, --verbose", "Expanded output with more details").option("--refs-only", "Output only references (for piping)").option("--count", "Output result counts by package").option("--format <format>", "Output format: human|summary|json", "human").option("--no-color", "Disable colored output").option("--json", "Output as JSON").option("--wait <ms>", "Max milliseconds to wait for indexing (default: 30000)").option("--no-wait", "Return immediately without waiting for indexing");
+  return cmd.option("-P, --packages <packages>", "Packages to search (comma-separated). Format: name or registry/name[@version]. Examples: express | express,lodash | pypi/django@4.2").option("-m, --mode <mode>", "Search mode: all (default), code, docs").option("-l, --limit <n>", "Max results (default: 25)").option("-v, --verbose", "Expanded output with more details").option("--refs-only", "Output only references (for piping)").option("--count", "Output result counts by package").option("--format <format>", "Output format: human|summary|json", "human").option("--no-color", "Disable colored output").option("--json", "Output as JSON").option("--wait <ms>", "Max milliseconds to wait for indexing (default: 30000)").option("--no-wait", "Return immediately without waiting for indexing").option("--resume <ref>", "Resume a previous search by reference").option("--no-poll", "Disable auto-polling for incomplete searches");
 }
 function registerSearchCommand(program) {
-  const cmd = program.command("search [query...]").summary("Search code and documentation across packages").description(SEARCH_DESCRIPTION);
+  const cmd = program.command("search [query...]").summary("Search code and documentation across packages").description(SEARCH_DESCRIPTION2);
   addSearchOptions(cmd).action(async (query, options) => {
     await withCliErrorHandling(options.json ?? false, async () => {
       const deps = await createContainer();
@@ -2905,6 +4113,70 @@ function registerDocsSearchCommand(program) {
     });
   });
 }
+// src/commands/index-cmd.ts
+async function indexAction(packages, options, deps) {
+  const { pkgseerService } = deps;
+  const input2 = {};
+  if (packages.length > 0) {
+    input2.packages = packages.map((spec) => {
+      const parsed = parsePackageSpec(spec);
+      return {
+        registry: toGraphQLRegistry(parsed.registry),
+        name: parsed.name,
+        version: parsed.version
+      };
+    });
+  }
+  if (options.repo && options.repo.length > 0) {
+    input2.repositories = options.repo.map((url) => ({
+      url,
+      ref: options.ref,
+      discoverPackages: options.discoverPackages
+    }));
+  }
+  if (!input2.packages?.length && !input2.repositories?.length) {
+    console.error("Error: Provide at least one package or --repo URL.");
+    process.exit(1);
+  }
+  const result = await pkgseerService.triggerIndexing(input2);
+  handleErrors(result.errors, options.json ?? false);
+  const data = result.data.triggerIndexing;
+  if (options.json) {
+    output(data, true);
+  } else {
+    if (data) {
+      console.log(`Accepted: ${data.accepted}`);
+      console.log(`Skipped: ${data.skipped}`);
+    } else {
+      console.log("Indexing request submitted.");
+    }
+  }
+}
+var INDEX_DESCRIPTION = `Trigger pre-indexing for packages or repositories.
+
+Requests that PkgSeer index the specified packages or repositories.
+Useful for warming up indexes before code navigation queries.
+
+Package specs support registry:name@version format.
+Repository URLs should be GitHub repository URLs.
+
+Examples:
+  pkgseer index npm:express npm:lodash
+  pkgseer index pypi:requests@2.31.0
+  pkgseer index --repo https://github.com/expressjs/express
+  pkgseer index --repo https://github.com/org/repo --ref v1.0.0 --discover-packages`;
+function registerIndexCommand(program) {
+  program.command("index [packages...]").summary("Trigger pre-indexing for packages or repositories").description(INDEX_DESCRIPTION).option("--repo <url>", "Repository URL to index (repeatable)", collectValues, []).option("--ref <ref>", "Git ref for repository indexing").option("--discover-packages", "Discover and index packages in repository").option("--json", "Output as JSON").action(async (packages, options) => {
+    await withCliErrorHandling(options.json ?? false, async () => {
+      const deps = await createContainer();
+      await indexAction(packages, options, deps);
+    });
+  });
+}
+function collectValues(value, previous) {
+  return [...previous, value];
+}
+
 // src/commands/shared-colors.ts
 var colors2 = {
   reset: "\x1B[0m",
@@ -4676,7 +5948,7 @@ function registerLogoutCommand(program) {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/tools/compare-packages.ts
+// src/tools/call-path.ts
 import { z as z3 } from "zod";
 
 // src/tools/shared.ts
@@ -4701,15 +5973,68 @@ function toGraphQLRegistry2(registry) {
     npm: "NPM",
     pypi: "PYPI",
     hex: "HEX",
-    crates: "CRATES"
+    crates: "CRATES",
+    nuget: "NUGET",
+    maven: "MAVEN",
+    zig: "ZIG",
+    vcpkg: "VCPKG"
   };
   return map[registry.toLowerCase()] || "NPM";
 }
+function toNavigationMode(mode) {
+  if (!mode)
+    return;
+  const upper = mode.toUpperCase();
+  if (upper === "SUMMARY" || upper === "DETAILED")
+    return upper;
+  return;
+}
+var VALID_SYMBOL_KINDS = new Set([
+  "FUNCTION",
+  "METHOD",
+  "CLASS",
+  "MODULE",
+  "INTERFACE",
+  "TYPE",
+  "DOC_SECTION"
+]);
+function toSymbolKind(kind) {
+  if (!kind)
+    return;
+  const upper = kind.toUpperCase();
+  if (VALID_SYMBOL_KINDS.has(upper))
+    return upper;
+  return;
+}
+function toListScope(scope) {
+  if (!scope)
+    return;
+  const upper = scope.toUpperCase();
+  if (upper === "EXPORTS" || upper === "FILE")
+    return upper;
+  return;
+}
 var schemas = {
-  registry: z2.enum(["npm", "pypi", "hex", "crates"]).describe("Package registry (npm, pypi, hex, or crates)"),
+  registry: z2.enum(["npm", "pypi", "hex", "crates", "nuget", "maven", "zig", "vcpkg"]).describe("Package registry (npm, pypi, hex, crates, nuget, maven, zig, or vcpkg)"),
   packageName: z2.string().max(255).describe("Name of the package"),
-  version: z2.string().max(100).optional().describe("Specific version (defaults to latest)")
+  version: z2.string().max(100).optional().describe("Specific version (defaults to latest)"),
+  navigationMode: z2.enum(["summary", "detailed"]).optional().describe("Response detail level. summary (default) returns core fields; detailed adds all optional fields."),
+  waitTimeoutMs: z2.number().int().min(0).max(30000).optional().describe("Max milliseconds to wait for package indexing (0-30000). 0 = error immediately if not indexed."),
+  symbolReference: z2.object({
+    symbol_id: z2.number().int().optional().describe("Direct symbol ID (preferred when available)"),
+    registry: z2.enum(["npm", "pypi", "hex", "crates", "nuget", "maven", "zig", "vcpkg"]).optional().describe("Package registry (required for name-based lookup)"),
+    package_name: z2.string().max(255).optional().describe("Package name (required for name-based lookup)"),
+    symbol_name: z2.string().max(500).optional().describe("Symbol name or qualified path (required for name-based lookup). Matches both short name and qualifiedPath.")
+  })
 };
+function toSymbolReferenceInput(ref) {
+  return {
+    symbolId: ref.symbol_id,
+    registry: ref.registry ? toGraphQLRegistry2(ref.registry) : undefined,
+    packageName: ref.package_name,
+    symbolName: ref.symbol_name
+  };
+}
 function buildHintedMessage(operation, message) {
   const lower = message.toLowerCase();
   const isTimeout = lower.includes("-32001") || lower.includes("timeout") || lower.includes("timed out");
@@ -4747,20 +6072,60 @@ function notFoundError(packageName, registry) {
   return errorResult(`Package not found: ${packageName} in ${registry}`);
 }
 
+// src/tools/call-path.ts
+var argsSchema = {
+  from: schemas.symbolReference.describe("Source symbol. Provide either symbol_id or registry + package_name + symbol_name."),
+  to: schemas.symbolReference.describe("Destination symbol. Provide either symbol_id or registry + package_name + symbol_name."),
+  max_depth: z3.number().int().min(1).max(10).optional().describe("Maximum path length to search (max hops between from and to)"),
+  mode: schemas.navigationMode,
+  wait_timeout_ms: schemas.waitTimeoutMs
+};
+function createCallPathTool(pkgseerService) {
+  return {
+    name: "call_path",
+    description: "Find the shortest call path between two symbols in the same package. " + "Uses BFS to find how function A eventually calls function B through intermediate calls. " + "Returns: whether a path was found, source and destination symbols, " + "and ordered call paths (shortest first) with hop details.",
+    schema: argsSchema,
+    handler: async (args, _extra) => {
+      return withErrorHandling("find call path", async () => {
+        const fromInput = toSymbolReferenceInput(args.from);
+        const toInput = toSymbolReferenceInput(args.to);
+        if (!fromInput.symbolId && (!fromInput.symbolName || !fromInput.registry || !fromInput.packageName)) {
+          return errorResult("Invalid 'from' symbol: provide either symbol_id or symbol_name with registry and package_name.");
+        }
+        if (!toInput.symbolId && (!toInput.symbolName || !toInput.registry || !toInput.packageName)) {
+          return errorResult("Invalid 'to' symbol: provide either symbol_id or symbol_name with registry and package_name.");
+        }
+        const result = await pkgseerService.callPath(fromInput, toInput, {
+          maxDepth: args.max_depth,
+          mode: toNavigationMode(args.mode),
+          waitTimeoutMs: args.wait_timeout_ms
+        });
+        const graphqlError = handleGraphQLErrors(result.errors);
+        if (graphqlError)
+          return graphqlError;
+        if (!result.data.callPath) {
+          return errorResult("Could not find call path. Verify the symbols exist and the package is indexed.");
+        }
+        return textResult(JSON.stringify(result.data.callPath, null, 2));
+      });
+    }
+  };
+}
 // src/tools/compare-packages.ts
-var packageInputSchema = z3.object({
-  registry: z3.enum(["npm", "pypi", "hex", "crates"]),
-  name: z3.string().max(255),
-  version: z3.string().max(100).optional()
+import { z as z4 } from "zod";
+var packageInputSchema = z4.object({
+  registry: z4.enum(["npm", "pypi", "hex", "crates"]),
+  name: z4.string().max(255),
+  version: z4.string().max(100).optional()
 });
-var argsSchema = {
-  packages: z3.array(packageInputSchema).min(2).max(10).describe("List of packages to compare (2-10 packages)")
+var argsSchema2 = {
+  packages: z4.array(packageInputSchema).min(2).max(10).describe("List of packages to compare (2-10 packages)")
 };
 function createComparePackagesTool(pkgseerService) {
   return {
     name: "compare_packages",
     description: "Compare 2-10 packages side-by-side. Use this when evaluating alternatives (e.g., react vs preact vs solid-js). " + "Returns for each package: quality score, download counts, vulnerability count, license, and latest version. " + "Supports cross-registry comparison (npm, pypi, hex, crates). " + 'Format: [{"registry":"npm","name":"lodash"},{"registry":"npm","name":"underscore"}]',
-    schema: argsSchema,
+    schema: argsSchema2,
     handler: async ({ packages }, _extra) => {
       return withErrorHandling("compare packages", async () => {
         const input2 = packages.map((pkg) => ({
@@ -4781,19 +6146,19 @@ function createComparePackagesTool(pkgseerService) {
   };
 }
 // src/tools/fetch-code-context.ts
-import { z as z4 } from "zod";
-var argsSchema2 = {
-  repo_url: z4.string().min(1).describe("Repository URL (GitHub). Example: https://github.com/expressjs/express"),
-  git_ref: z4.string().min(1).describe("Git reference (tag, commit, or branch). Example: v4.18.2"),
-  file_path: z4.string().min(1).describe("Path to file in repository. Example: src/router/index.js"),
-  start_line: z4.number().int().positive().optional().describe("Starting line (1-indexed). If omitted, starts from line 1."),
-  end_line: z4.number().int().positive().optional().describe("Ending line. If omitted, returns to end of file.")
+import { z as z5 } from "zod";
+var argsSchema3 = {
+  repo_url: z5.string().min(1).describe("Repository URL (GitHub). Example: https://github.com/expressjs/express"),
+  git_ref: z5.string().min(1).describe("Git reference (tag, commit, or branch). Example: v4.18.2"),
+  file_path: z5.string().min(1).describe("Path to file in repository. Example: src/router/index.js"),
+  start_line: z5.number().int().positive().optional().describe("Starting line (1-indexed). If omitted, starts from line 1."),
+  end_line: z5.number().int().positive().optional().describe("Ending line. If omitted, returns to end of file.")
 };
 function createFetchCodeContextTool(pkgseerService) {
   return {
     name: "fetch_code_context",
     description: "Fetch code content from a repository. Use this to expand code search results and see " + "more context around a match. Returns full file by default, or a specific line range. " + "Requires repo_url, git_ref (tag/commit/branch), and file_path from search results.",
-    schema: argsSchema2,
+    schema: argsSchema3,
     handler: async ({ repo_url, git_ref, file_path, start_line, end_line }, _extra) => {
       return withErrorHandling("fetch code context", async () => {
         const result = await pkgseerService.fetchCodeContext(repo_url, git_ref, file_path, {
@@ -4812,15 +6177,15 @@ function createFetchCodeContextTool(pkgseerService) {
   };
 }
 // src/tools/fetch-package-doc.ts
-import { z as z5 } from "zod";
-var argsSchema3 = {
-  page_id: z5.string().max(500).describe("Globally unique documentation page identifier (from list_package_docs)")
+import { z as z6 } from "zod";
+var argsSchema4 = {
+  page_id: z6.string().max(500).describe("Globally unique documentation page identifier (from list_package_docs)")
 };
 function createFetchPackageDocTool(pkgseerService) {
   return {
     name: "fetch_package_doc",
     description: "Get full content of a documentation page. Requires page_id from list_package_docs. " + "Returns: title, full content (markdown/HTML), format type, navigation breadcrumbs, " + "source URL, and last updated timestamp. Use this when you need complete documentation, " + "not just search snippets.",
-    schema: argsSchema3,
+    schema: argsSchema4,
     handler: async ({ page_id }, _extra) => {
       return withErrorHandling("fetch documentation page", async () => {
         const result = await pkgseerService.getDocPage(page_id);
@@ -4835,8 +6200,60 @@ function createFetchPackageDocTool(pkgseerService) {
     }
   };
 }
+// src/tools/find-symbol.ts
+import { z as z7 } from "zod";
+var argsSchema5 = {
+  registry: schemas.registry,
+  package_name: schemas.packageName.describe("Name of the package to search for symbols"),
+  name: z7.string().max(500).optional().describe("Symbol name to search for (exact match or prefix). Omit to return all public exports."),
+  namespace: z7.string().max(500).optional().describe("Filter by namespace/module path prefix"),
+  kind: z7.enum([
+    "function",
+    "method",
+    "class",
+    "module",
+    "interface",
+    "type",
+    "doc_section"
+  ]).optional().describe("Filter by symbol kind"),
+  public_only: z7.boolean().optional().describe("Only return public/exported symbols"),
+  version: schemas.version,
+  include_code: z7.boolean().optional().describe("Include source code in results"),
+  context_lines: z7.number().int().min(0).max(30).optional().describe("Lines of surrounding context when include_code=true (max 30)"),
+  mode: schemas.navigationMode,
+  wait_timeout_ms: schemas.waitTimeoutMs
+};
+function createFindSymbolTool(pkgseerService) {
+  return {
+    name: "find_symbol",
+    description: "Find functions, methods, or classes by name in a package. " + "Use for targeted lookups when you know the symbol name. " + "Returns: symbol ID, name, qualified path, kind, file location, and optionally source code. " + "Omit name to get all public exports. Use namespace to filter by module path.",
+    schema: argsSchema5,
+    handler: async (args, _extra) => {
+      return withErrorHandling("find symbol", async () => {
+        const result = await pkgseerService.findSymbol(toGraphQLRegistry2(args.registry), args.package_name, {
+          name: args.name,
+          namespace: args.namespace,
+          kind: toSymbolKind(args.kind),
+          publicOnly: args.public_only,
+          version: args.version,
+          includeCode: args.include_code,
+          contextLines: args.context_lines,
+          mode: toNavigationMode(args.mode),
+          waitTimeoutMs: args.wait_timeout_ms
+        });
+        const graphqlError = handleGraphQLErrors(result.errors);
+        if (graphqlError)
+          return graphqlError;
+        if (!result.data.findSymbol) {
+          return notFoundError(args.package_name, args.registry);
+        }
+        return textResult(JSON.stringify(result.data.findSymbol, null, 2));
+      });
+    }
+  };
+}
 // src/tools/list-package-docs.ts
-var argsSchema4 = {
+var argsSchema6 = {
   registry: schemas.registry,
   package_name: schemas.packageName.describe("Name of the package to list documentation for"),
   version: schemas.version
@@ -4845,7 +6262,7 @@ function createListPackageDocsTool(pkgseerService) {
   return {
     name: "list_package_docs",
     description: "Discover available documentation pages for a package. Start here before fetching or searching docs. " + "Returns: page titles, unique IDs (needed for fetch_package_doc), word counts, and update timestamps. " + "Workflow: list_package_docs → fetch_package_doc for full content, or search_package_docs to find specific topics.",
-    schema: argsSchema4,
+    schema: argsSchema6,
     handler: async ({ registry, package_name, version: version2 }, _extra) => {
       return withErrorHandling("list package documentation", async () => {
         const result = await pkgseerService.listPackageDocs(toGraphQLRegistry2(registry), package_name, version2);
@@ -4860,14 +6277,69 @@ function createListPackageDocsTool(pkgseerService) {
     }
   };
 }
+// src/tools/list-symbols.ts
+import { z as z8 } from "zod";
+var argsSchema7 = {
+  registry: schemas.registry,
+  package_name: schemas.packageName.describe("Name of the package to browse symbols for"),
+  scope: z8.enum(["exports", "file"]).describe("Browsing scope: 'exports' for public API, 'file' for all symbols in a specific file"),
+  file_path: z8.string().max(1000).optional().describe("File path within the repo (required when scope=file)"),
+  namespace: z8.string().max(500).optional().describe("Filter by namespace prefix (e.g., 'React' to see React.*)"),
+  public_only: z8.boolean().optional().describe("Only return public symbols"),
+  include_popularity: z8.boolean().optional().describe("Include callerCount for each symbol (slightly slower)"),
+  limit: z8.number().int().min(1).max(100).optional().describe("Max symbols to return (max 100)"),
+  version: schemas.version,
+  mode: schemas.navigationMode,
+  wait_timeout_ms: schemas.waitTimeoutMs
+};
+function createListSymbolsTool(pkgseerService) {
+  return {
+    name: "list_symbols",
+    description: "Browse symbols in a package by scope. " + "Use scope='exports' for public API exploration with namespace grouping and optional popularity data. " + "Use scope='file' with file_path to see all symbols in a specific file. " + "Returns: symbols with IDs, names, qualified paths, kinds, and file locations.",
+    schema: argsSchema7,
+    handler: async (args, _extra) => {
+      return withErrorHandling("list symbols", async () => {
+        const scope = toListScope(args.scope);
+        if (!scope) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Invalid scope. Use 'exports' or 'file'."
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = await pkgseerService.listSymbols(toGraphQLRegistry2(args.registry), args.package_name, scope, {
+          filePath: args.file_path,
+          namespace: args.namespace,
+          publicOnly: args.public_only,
+          includePopularity: args.include_popularity,
+          limit: args.limit,
+          version: args.version,
+          mode: toNavigationMode(args.mode),
+          waitTimeoutMs: args.wait_timeout_ms
+        });
+        const graphqlError = handleGraphQLErrors(result.errors);
+        if (graphqlError)
+          return graphqlError;
+        if (!result.data.listSymbols) {
+          return notFoundError(args.package_name, args.registry);
+        }
+        return textResult(JSON.stringify(result.data.listSymbols, null, 2));
+      });
+    }
+  };
+}
 // src/tools/package-dependencies.ts
-import { z as z6 } from "zod";
-var argsSchema5 = {
+import { z as z9 } from "zod";
+var argsSchema8 = {
   registry: schemas.registry,
   package_name: schemas.packageName.describe("Name of the package to retrieve dependencies for"),
   version: schemas.version,
-  include_transitive: z6.boolean().optional().describe("Whether to include transitive dependency DAG"),
-  max_depth: z6.number().int().min(1).max(10).optional().describe("Maximum depth for transitive traversal (1-10)")
+  include_transitive: z9.boolean().optional().describe("Whether to include transitive dependency DAG"),
+  max_depth: z9.number().int().min(1).max(10).optional().describe("Maximum depth for transitive traversal (1-10)")
 };
 function decodeDag(rawDag) {
   if (!rawDag || typeof rawDag !== "object")
@@ -4945,7 +6417,7 @@ function createPackageDependenciesTool(pkgseerService) {
   return {
     name: "package_dependencies",
     description: "Analyze package dependencies. By default returns direct dependencies only. " + "Set include_transitive=true to get the full dependency tree (use max_depth to limit large trees). " + "Returns: dependency names, version constraints, and for transitive deps, a graph with depth levels. " + "Use this to understand complexity before adding a package, or to find nested dependencies.",
-    schema: argsSchema5,
+    schema: argsSchema8,
     handler: async ({ registry, package_name, version: version2, include_transitive, max_depth }, _extra) => {
       return withErrorHandling("fetch package dependencies", async () => {
         const result = await pkgseerService.getPackageDependencies(toGraphQLRegistry2(registry), package_name, version2, include_transitive, max_depth);
@@ -4982,8 +6454,46 @@ function createPackageDependenciesTool(pkgseerService) {
     }
   };
 }
+// src/tools/package-imports.ts
+import { z as z10 } from "zod";
+var argsSchema9 = {
+  registry: schemas.registry,
+  package_name: schemas.packageName.describe("Name of the package to get imports for"),
+  file_path: z10.string().max(1000).optional().describe("Filter to a specific file path"),
+  resolved_only: z10.boolean().optional().describe("Only return imports resolved to a known package"),
+  limit: z10.number().int().min(1).max(500).optional().describe("Max imports to return"),
+  version: schemas.version,
+  mode: schemas.navigationMode,
+  wait_timeout_ms: schemas.waitTimeoutMs
+};
+function createPackageImportsTool(pkgseerService) {
+  return {
+    name: "package_imports",
+    description: "Get import statements in a package. " + "Returns parsed import/require/use statements with optional resolution to known packages. " + "Use resolved_only=true to see only imports that map to packages in the PkgSeer registry. " + "Includes: source path, imported names, and de-duplicated dependency list.",
+    schema: argsSchema9,
+    handler: async (args, _extra) => {
+      return withErrorHandling("fetch package imports", async () => {
+        const result = await pkgseerService.packageImports(toGraphQLRegistry2(args.registry), args.package_name, {
+          filePath: args.file_path,
+          resolvedOnly: args.resolved_only,
+          limit: args.limit,
+          version: args.version,
+          mode: toNavigationMode(args.mode),
+          waitTimeoutMs: args.wait_timeout_ms
+        });
+        const graphqlError = handleGraphQLErrors(result.errors);
+        if (graphqlError)
+          return graphqlError;
+        if (!result.data.packageImports) {
+          return notFoundError(args.package_name, args.registry);
+        }
+        return textResult(JSON.stringify(result.data.packageImports, null, 2));
+      });
+    }
+  };
+}
 // src/tools/package-quality.ts
-var argsSchema6 = {
+var argsSchema10 = {
   registry: schemas.registry,
   package_name: schemas.packageName.describe("Name of the package to analyze"),
   version: schemas.version
@@ -4992,7 +6502,7 @@ function createPackageQualityTool(pkgseerService) {
   return {
     name: "package_quality",
     description: "Evaluate package maintenance health and code quality. Use this to assess if a package is well-maintained " + "before adding it as a dependency. Returns: overall score (0-100), category scores (documentation, " + "testing, community, maintenance), and individual rule results with pass/fail status. " + "Useful for comparing quality between alternative packages.",
-    schema: argsSchema6,
+    schema: argsSchema10,
     handler: async ({ registry, package_name, version: version2 }, _extra) => {
       return withErrorHandling("fetch package quality", async () => {
         const result = await pkgseerService.getPackageQuality(toGraphQLRegistry2(registry), package_name, version2);
@@ -5008,7 +6518,7 @@ function createPackageQualityTool(pkgseerService) {
   };
 }
 // src/tools/package-summary.ts
-var argsSchema7 = {
+var argsSchema11 = {
   registry: schemas.registry,
   package_name: schemas.packageName.describe("Name of the package to retrieve summary for")
 };
@@ -5016,7 +6526,7 @@ function createPackageSummaryTool(pkgseerService) {
   return {
     name: "package_summary",
     description: "Get a comprehensive overview of a package. Use this as your first tool when researching a package. " + "Returns: description, latest version, license, repository URL, download stats, " + "active security advisories count, and quickstart/installation instructions. " + "For deeper analysis, follow up with package_quality (maintenance health) or " + "package_vulnerabilities (security details).",
-    schema: argsSchema7,
+    schema: argsSchema11,
     handler: async ({ registry, package_name }, _extra) => {
       return withErrorHandling("fetch package summary", async () => {
         const result = await pkgseerService.getPackageSummary(toGraphQLRegistry2(registry), package_name);
@@ -5032,7 +6542,7 @@ function createPackageSummaryTool(pkgseerService) {
   };
 }
 // src/tools/package-vulnerabilities.ts
-var argsSchema8 = {
+var argsSchema12 = {
   registry: schemas.registry,
   package_name: schemas.packageName.describe("Name of the package to inspect for vulnerabilities"),
   version: schemas.version
@@ -5041,7 +6551,7 @@ function createPackageVulnerabilitiesTool(pkgseerService) {
   return {
     name: "package_vulnerabilities",
     description: "Check security vulnerabilities for a package. Use this before adding dependencies or when auditing existing ones. " + "Returns: list of CVEs/advisories with severity levels, affected version ranges, fixed versions, " + "and upgrade recommendations. If version is specified, shows only vulnerabilities affecting that version.",
-    schema: argsSchema8,
+    schema: argsSchema12,
     handler: async ({ registry, package_name, version: version2 }, _extra) => {
       return withErrorHandling("fetch package vulnerabilities", async () => {
         const result = await pkgseerService.getPackageVulnerabilities(toGraphQLRegistry2(registry), package_name, version2);
@@ -5057,19 +6567,19 @@ function createPackageVulnerabilitiesTool(pkgseerService) {
   };
 }
 // src/tools/search.ts
-import { z as z7 } from "zod";
-var packageInputSchema2 = z7.object({
+import { z as z11 } from "zod";
+var packageInputSchema2 = z11.object({
   registry: schemas.registry,
-  name: z7.string().min(1).describe("Package name"),
-  version: z7.string().optional().describe("Specific version (defaults to latest)")
+  name: z11.string().min(1).describe("Package name"),
+  version: z11.string().optional().describe("Specific version (defaults to latest)")
 });
 var DEFAULT_AGENT_WAIT_TIMEOUT_MS = 1e4;
-var argsSchema9 = {
-  packages: z7.array(packageInputSchema2).min(1).max(20).describe("Packages to search (1-20). Each package needs registry and name."),
-  query: z7.string().min(1).describe("Search query - natural language or keywords"),
-  mode: z7.enum(["all", "code", "docs"]).optional().describe('Search mode: "all" (default), "code" only, or "docs" only'),
-  limit: z7.number().int().min(1).max(100).optional().describe("Maximum results (default: 20)"),
-  waitTimeoutMs: z7.number().int().min(0).max(60000).optional().describe("Max milliseconds to wait for indexing (default: 10000, 0=immediate)")
+var argsSchema13 = {
+  packages: z11.array(packageInputSchema2).min(1).max(20).describe("Packages to search (1-20). Each package needs registry and name."),
+  query: z11.string().min(1).describe("Search query - natural language or keywords"),
+  mode: z11.enum(["all", "code", "docs"]).optional().describe('Search mode: "all" (default), "code" only, or "docs" only'),
+  limit: z11.number().int().min(1).max(100).optional().describe("Maximum results (default: 20)"),
+  waitTimeoutMs: z11.number().int().min(0).max(60000).optional().describe("Max milliseconds to wait for indexing (default: 10000, 0=immediate)")
 };
 function toSearchMode2(mode) {
   if (!mode)
@@ -5108,7 +6618,7 @@ function createSearchTool(pkgseerService) {
   return {
     name: "search",
     description: "Search code and documentation across packages. Returns functions, classes, and documentation pages " + "matching your query. Use mode='code' for code only, mode='docs' for documentation only, or " + "mode='all' (default) for both. Provide 1-20 packages to search. Results include relevance scores " + "and snippets showing matches. If packages need indexing, the search will wait up to waitTimeoutMs " + "(default 10s). If not complete, returns progress info with searchRef for follow-up.",
-    schema: argsSchema9,
+    schema: argsSchema13,
     handler: async ({ packages, query, mode, limit, waitTimeoutMs }, _extra) => {
       return withErrorHandling("search packages", async () => {
         const normalizedQuery = query.trim();
@@ -5160,21 +6670,21 @@ function createSearchTool(pkgseerService) {
   };
 }
 // src/tools/search-project-docs.ts
-import { z as z8 } from "zod";
-var argsSchema10 = {
-  project_directory: z8.string().optional().describe("Directory to search for pkgseer.yml configuration. " + "Use this to specify which project's context to use when the MCP server " + "is installed at user level. Defaults to MCP server's working directory."),
-  project: z8.string().optional().describe("Project name to search. Overrides value from pkgseer.yml if provided."),
-  terms: z8.array(z8.string()).optional().describe("Search terms to match. Provide a few key words or phrases that should appear in results."),
-  match_mode: z8.enum(["any", "or", "all", "and"]).optional().describe('How to combine terms: "any" (OR) or "all" (AND).'),
-  include_snippets: z8.boolean().optional().describe("Include content excerpts around matches"),
-  limit: z8.number().int().min(1).max(100).optional().describe("Maximum number of results to return")
+import { z as z12 } from "zod";
+var argsSchema14 = {
+  project_directory: z12.string().optional().describe("Directory to search for pkgseer.yml configuration. " + "Use this to specify which project's context to use when the MCP server " + "is installed at user level. Defaults to MCP server's working directory."),
+  project: z12.string().optional().describe("Project name to search. Overrides value from pkgseer.yml if provided."),
+  terms: z12.array(z12.string()).optional().describe("Search terms to match. Provide a few key words or phrases that should appear in results."),
+  match_mode: z12.enum(["any", "or", "all", "and"]).optional().describe('How to combine terms: "any" (OR) or "all" (AND).'),
+  include_snippets: z12.boolean().optional().describe("Include content excerpts around matches"),
+  limit: z12.number().int().min(1).max(100).optional().describe("Maximum number of results to return")
 };
 function createSearchProjectDocsTool(deps) {
   const { pkgseerService, configService, defaultProjectDir } = deps;
   return {
     name: "search_project_docs",
     description: "Searches documentation across all dependencies in a PkgSeer project using search terms and match modes (any/all). Returns ranked results from multiple packages. Use project_directory to specify which project's context to use, or project to search a specific project directly.",
-    schema: argsSchema10,
+    schema: argsSchema14,
     handler: async ({
       project_directory,
       project,
@@ -5219,6 +6729,234 @@ function createSearchProjectDocsTool(deps) {
     }
   };
 }
+// src/tools/search-status.ts
+import { z as z13 } from "zod";
+var argsSchema15 = {
+  searchRef: z13.string().min(1).describe("Search reference from a previous incomplete search")
+};
+function createSearchStatusTool(pkgseerService) {
+  return {
+    name: "search_status",
+    description: "Check the status of an async search and get results if complete. " + "Use this after a search returns incomplete (completed=false) to poll for completion. " + "Returns status (PENDING, INDEXING, SEARCHING, COMPLETED, TIMEOUT, FAILED), " + "progress info (packagesReady/packagesTotal), and results when status is COMPLETED.",
+    schema: argsSchema15,
+    handler: async ({ searchRef }, _extra) => {
+      return withErrorHandling("check search status", async () => {
+        const progressResult = await pkgseerService.getSearchProgress(searchRef);
+        const graphqlError = handleGraphQLErrors(progressResult.errors);
+        if (graphqlError)
+          return graphqlError;
+        const progress = progressResult.data.searchProgress;
+        if (!progress) {
+          return errorResult("Search session not found. It may have expired (sessions last 1 hour).");
+        }
+        if (progress.status === "COMPLETED") {
+          const resultsResponse = await pkgseerService.getSearchResults(searchRef);
+          const resultsError = handleGraphQLErrors(resultsResponse.errors);
+          if (resultsError)
+            return resultsError;
+          const searchResults = resultsResponse.data.searchResults;
+          if (!searchResults) {
+            return errorResult("Search completed but results are no longer available. " + "The session may have expired (sessions last 1 hour).");
+          }
+          return textResult(JSON.stringify({
+            status: progress.status,
+            searchRef: progress.searchRef,
+            result: searchResults
+          }, null, 2));
+        }
+        return textResult(JSON.stringify({
+          status: progress.status,
+          searchRef: progress.searchRef,
+          progress: {
+            packagesTotal: progress.packagesTotal,
+            packagesReady: progress.packagesReady,
+            elapsedMs: progress.elapsedMs
+          },
+          message: progress.status === "FAILED" ? "Search failed." : progress.status === "TIMEOUT" ? "Search timed out before completion." : "Search is still in progress. Poll again to check status."
+        }, null, 2));
+      });
+    }
+  };
+}
+// src/tools/search-symbols.ts
+import { z as z14 } from "zod";
+var argsSchema16 = {
+  registry: schemas.registry,
+  package_name: schemas.packageName.describe("Name of the package to search within"),
+  query: z14.string().max(500).describe("Search query for full-text code search (max 500 chars)"),
+  kind: z14.enum([
+    "function",
+    "method",
+    "class",
+    "module",
+    "interface",
+    "type",
+    "doc_section"
+  ]).optional().describe("Filter results by code chunk type"),
+  version: schemas.version,
+  limit: z14.number().int().min(1).max(50).optional().describe("Max results to return (max 50)"),
+  mode: schemas.navigationMode,
+  wait_timeout_ms: schemas.waitTimeoutMs
+};
+function createSearchSymbolsTool(pkgseerService) {
+  return {
+    name: "search_symbols",
+    description: "Full-text search within package code. " + "Searches across functions, classes, modules, and doc sections. " + "Returns: matching code chunks with name, type, file path, line numbers, " + "and content previews. Use for finding implementations by keyword.",
+    schema: argsSchema16,
+    handler: async (args, _extra) => {
+      return withErrorHandling("search symbols", async () => {
+        const result = await pkgseerService.searchSymbols(toGraphQLRegistry2(args.registry), args.package_name, args.query, {
+          kind: toSymbolKind(args.kind),
+          version: args.version,
+          limit: args.limit,
+          mode: toNavigationMode(args.mode),
+          waitTimeoutMs: args.wait_timeout_ms
+        });
+        const graphqlError = handleGraphQLErrors(result.errors);
+        if (graphqlError)
+          return graphqlError;
+        if (!result.data.searchSymbols) {
+          return notFoundError(args.package_name, args.registry);
+        }
+        return textResult(JSON.stringify(result.data.searchSymbols, null, 2));
+      });
+    }
+  };
+}
+// src/tools/symbol-callees.ts
+import { z as z15 } from "zod";
+var argsSchema17 = {
+  symbol: schemas.symbolReference.describe("Symbol to find callees for. Provide either symbol_id or registry + package_name + symbol_name."),
+  max_depth: z15.number().int().min(1).max(5).optional().describe("BFS traversal depth (1 = direct callees only, 2+ = transitive, max 5)"),
+  limit: z15.number().int().min(1).max(100).optional().describe("Maximum dependency entries to return"),
+  include_external: z15.boolean().optional().describe("Include calls to symbols in other packages"),
+  include_builtins: z15.boolean().optional().describe("Include calls to built-in/standard library functions (console, Math, etc.)"),
+  mode: schemas.navigationMode,
+  wait_timeout_ms: schemas.waitTimeoutMs
+};
+function createSymbolCalleesTool(pkgseerService) {
+  return {
+    name: "symbol_callees",
+    description: "Find what a symbol calls (its dependencies). " + "Returns direct callees at max_depth=1, or transitive call chains at higher depths. " + "Includes: callee names, qualified paths, file locations, call lines, " + "and external package references. Use to understand a function's dependency footprint.",
+    schema: argsSchema17,
+    handler: async (args, _extra) => {
+      return withErrorHandling("find symbol callees", async () => {
+        const symbolInput = toSymbolReferenceInput(args.symbol);
+        if (!symbolInput.symbolId && (!symbolInput.symbolName || !symbolInput.registry || !symbolInput.packageName)) {
+          return errorResult("Provide either symbol_id or symbol_name with registry and package_name to identify the symbol.");
+        }
+        const result = await pkgseerService.symbolDependencies(symbolInput, {
+          maxDepth: args.max_depth,
+          maxResults: args.limit,
+          includeExternal: args.include_external,
+          includeBuiltins: args.include_builtins,
+          mode: toNavigationMode(args.mode),
+          waitTimeoutMs: args.wait_timeout_ms
+        });
+        const graphqlError = handleGraphQLErrors(result.errors);
+        if (graphqlError)
+          return graphqlError;
+        if (!result.data.symbolDependencies) {
+          return errorResult("Symbol not found. Verify the symbol reference and that the package is indexed.");
+        }
+        return textResult(JSON.stringify(result.data.symbolDependencies, null, 2));
+      });
+    }
+  };
+}
+// src/tools/symbol-callers.ts
+import { z as z16 } from "zod";
+var argsSchema18 = {
+  symbol: schemas.symbolReference.describe("Symbol to find callers for. Provide either symbol_id or registry + package_name + symbol_name."),
+  same_package_only: z16.boolean().optional().describe("Only return callers from the same package"),
+  limit: z16.number().int().min(1).max(100).optional().describe("Maximum entries to return"),
+  mode: schemas.navigationMode,
+  wait_timeout_ms: schemas.waitTimeoutMs
+};
+function createSymbolCallersTool(pkgseerService) {
+  return {
+    name: "symbol_callers",
+    description: "Find what calls a symbol (its dependents/callers). " + "Returns: the target symbol and a list of symbols that call it, " + "with their file locations and call line numbers. " + "Use same_package_only to limit to callers within the same package.",
+    schema: argsSchema18,
+    handler: async (args, _extra) => {
+      return withErrorHandling("find symbol callers", async () => {
+        const symbolInput = toSymbolReferenceInput(args.symbol);
+        if (!symbolInput.symbolId && (!symbolInput.symbolName || !symbolInput.registry || !symbolInput.packageName)) {
+          return errorResult("Provide either symbol_id or symbol_name with registry and package_name to identify the symbol.");
+        }
+        const result = await pkgseerService.symbolDependents(symbolInput, {
+          samePackageOnly: args.same_package_only,
+          maxResults: args.limit,
+          mode: toNavigationMode(args.mode),
+          waitTimeoutMs: args.wait_timeout_ms
+        });
+        const graphqlError = handleGraphQLErrors(result.errors);
+        if (graphqlError)
+          return graphqlError;
+        if (!result.data.symbolDependents) {
+          return errorResult("Symbol not found. Verify the symbol reference and that the package is indexed.");
+        }
+        return textResult(JSON.stringify(result.data.symbolDependents, null, 2));
+      });
+    }
+  };
+}
+// src/tools/trigger-indexing.ts
+import { z as z17 } from "zod";
+var packageInputSchema3 = z17.object({
+  registry: schemas.registry,
+  name: z17.string().max(255).describe("Package name"),
+  version: z17.string().max(100).optional().describe("Specific version to index")
+});
+var repositoryInputSchema = z17.object({
+  url: z17.string().max(2000).describe("GitHub repository URL"),
+  ref: z17.string().max(200).optional().describe("Git ref to index (tag, branch, commit). Defaults to HEAD"),
+  discover_packages: z17.boolean().optional().describe("If true, discover packages published from this repo and trigger their metadata fetch")
+});
+var argsSchema19 = {
+  packages: z17.array(packageInputSchema3).max(100).optional().describe("Package versions to index (max 100)"),
+  repositories: z17.array(repositoryInputSchema).max(50).optional().describe("Repository URLs to index (max 50)")
+};
+function createTriggerIndexingTool(pkgseerService) {
+  return {
+    name: "trigger_indexing",
+    description: "Pre-warm PkgSeer indexes by triggering indexing for packages and/or repositories. " + "Fire-and-forget: triggers jobs and returns immediately with accepted/skipped counts. " + "Use before search requests to ensure packages are indexed. " + "Rate limited to 10 requests per minute.",
+    schema: argsSchema19,
+    handler: async (args, _extra) => {
+      return withErrorHandling("trigger indexing", async () => {
+        const packages = args.packages?.map((p) => ({
+          registry: toGraphQLRegistry2(p.registry),
+          name: p.name,
+          version: p.version
+        }));
+        const repositories = args.repositories?.map((r) => ({
+          url: r.url,
+          ref: r.ref,
+          discoverPackages: r.discover_packages
+        }));
+        const result = await pkgseerService.triggerIndexing({
+          packages,
+          repositories
+        });
+        const graphqlError = handleGraphQLErrors(result.errors);
+        if (graphqlError)
+          return graphqlError;
+        if (!result.data.triggerIndexing) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Indexing request failed. Check authentication and input."
+              }
+            ],
+            isError: true
+          };
+        }
+        return textResult(JSON.stringify(result.data.triggerIndexing, null, 2));
+      });
+    }
+  };
+}
 // src/commands/mcp.ts
 var TOOL_FACTORIES = {
   package_summary: ({ pkgseerService }) => createPackageSummaryTool(pkgseerService),
@@ -5229,12 +6967,21 @@ var TOOL_FACTORIES = {
   list_package_docs: ({ pkgseerService }) => createListPackageDocsTool(pkgseerService),
   fetch_package_doc: ({ pkgseerService }) => createFetchPackageDocTool(pkgseerService),
   search: ({ pkgseerService }) => createSearchTool(pkgseerService),
+  search_status: ({ pkgseerService }) => createSearchStatusTool(pkgseerService),
   fetch_code_context: ({ pkgseerService }) => createFetchCodeContextTool(pkgseerService),
   search_project_docs: ({ pkgseerService, configService, defaultProjectDir }) => createSearchProjectDocsTool({
     pkgseerService,
     configService,
     defaultProjectDir
-  })
+  }),
+  find_symbol: ({ pkgseerService }) => createFindSymbolTool(pkgseerService),
+  search_symbols: ({ pkgseerService }) => createSearchSymbolsTool(pkgseerService),
+  list_symbols: ({ pkgseerService }) => createListSymbolsTool(pkgseerService),
+  symbol_callers: ({ pkgseerService }) => createSymbolCallersTool(pkgseerService),
+  symbol_callees: ({ pkgseerService }) => createSymbolCalleesTool(pkgseerService),
+  package_imports: ({ pkgseerService }) => createPackageImportsTool(pkgseerService),
+  call_path: ({ pkgseerService }) => createCallPathTool(pkgseerService),
+  trigger_indexing: ({ pkgseerService }) => createTriggerIndexingTool(pkgseerService)
 };
 var PUBLIC_READ_TOOLS = [
   "package_summary",
@@ -5245,7 +6992,16 @@ var PUBLIC_READ_TOOLS = [
   "list_package_docs",
   "fetch_package_doc",
   "search",
-  "fetch_code_context"
+  "search_status",
+  "fetch_code_context",
+  "find_symbol",
+  "search_symbols",
+  "list_symbols",
+  "symbol_callers",
+  "symbol_callees",
+  "package_imports",
+  "call_path",
+  "trigger_indexing"
 ];
 var PROJECT_READ_TOOLS = ["search_project_docs"];
 var ALL_TOOLS = [...PUBLIC_READ_TOOLS, ...PROJECT_READ_TOOLS];
@@ -6245,6 +8001,18 @@ Documentation commands:
   pkgseer docs get <pkg> <page>   Fetch a doc page
   pkgseer docs search <query>     Search docs only
 
+Code navigation commands:
+  pkgseer code find <pkg> [name]  Find symbols by name
+  pkgseer code search <pkg> <q>   Search in package code
+  pkgseer code list <package>     Browse package symbols
+  pkgseer code callers <symbol>   Find what calls a symbol
+  pkgseer code callees <symbol>   Find what a symbol calls
+  pkgseer code imports <package>  List package imports
+  pkgseer code path <from> <to>   Find call path between symbols
+
+Indexing:
+  pkgseer index <packages...>     Trigger pre-indexing
+
 Learn more at https://pkgseer.dev`);
 registerInitCommand(program);
 registerMcpCommand(program);
@@ -6266,6 +8034,15 @@ var docs = program.command("docs").description("Package documentation commands")
 registerDocsListCommand(docs);
 registerDocsGetCommand(docs);
 registerDocsSearchCommand(docs);
+var code = program.command("code").description("Code navigation commands");
+registerCodeFindCommand(code);
+registerCodeSearchCommand(code);
+registerCodeListCommand(code);
+registerCodeCallersCommand(code);
+registerCodeCalleesCommand(code);
+registerCodeImportsCommand(code);
+registerCodePathCommand(code);
+registerIndexCommand(program);
 var project = program.command("project").description("Project management commands");
 registerProjectInitCommand(project);
 registerProjectDetectCommand(project);