@mka-rainmaker/ama 0.1.0

package/dist/query/service.d.ts

@@ -0,0 +1,329 @@
+import type { EdgeKind, EdgeProvenance, GraphNode, NodeKind } from "../graph/index.js";
+import type { FileMeta, Store } from "../store/types.js";
+export interface SearchOptions {
+    /** Maximum number of hits to return (default 50). */
+    limit?: number;
+    /** Restrict to a single node kind. */
+    kind?: NodeKind;
+}
+/** A search plus a confidence signal (ama-b79). */
+export interface SearchResult {
+    results: GraphNode[];
+    /** True when there are results but none is an exact or name-prefix match — the
+     *  best is only a loose substring/qualified hit, so the caller should refine. */
+    lowConfidence: boolean;
+}
+export interface Snippet {
+    id: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+    text: string;
+}
+/** A neighbour reached across one edge, carrying that edge's metadata: the
+ *  call-site location (ama-hft.9) and provenance (ama-m8k.1). Returned by
+ *  find_callers/find_callees so an agent sees not just who, but where. */
+export interface EdgeNeighbor {
+    /** The symbol at the other end of the edge (the caller, or the callee). */
+    symbol: GraphNode;
+    /** Which edge kind connected them — e.g. `Calls` vs `Instantiates` (a `new X()`
+     *  construction), so the two are separable in one result. (ama-hft.11) */
+    via: EdgeKind;
+    /** The call-site line/column, when the edge records one. */
+    at?: {
+        line: number;
+        column: number;
+    };
+    /** Every call site, when the caller invokes the target more than once
+     *  (`sites[0] === at`). Absent for single-site edges. (ama-hft.10) */
+    sites?: {
+        line: number;
+        column: number;
+    }[];
+    /** How the edge was derived; absent ⇒ resolved. */
+    provenance?: EdgeProvenance;
+}
+/** Everything about one node in a single answer — the higher-order `node` query. */
+export interface NodeView {
+    /** The resolved node itself (most-specific match for the ref). */
+    node: GraphNode;
+    /** Verbatim source, when the node has a known location. */
+    snippet?: Snippet;
+    /** Symbols this node defines, in source order — a class's methods/properties, an
+     *  interface's members, a namespace's or file's symbols. Empty for a leaf, so a
+     *  class is a complete structured outline without re-reading the snippet. (ama-as5) */
+    members: GraphNode[];
+    /** Symbols that call it. */
+    callers: GraphNode[];
+    /** Symbols it calls. */
+    callees: GraphNode[];
+    /** Symbols that reference it via a References edge — variable readers, the
+     *  routes that map to a handler, and other dispatch references. */
+    referrers: GraphNode[];
+    /** Files that import (or re-export) it. */
+    dependents: GraphNode[];
+    /** Inheritance, so the overview is complete for OOP symbols (each empty when N/A):
+     *  for a method, the supertype methods it overrides and the subtype methods that
+     *  override it; for a class, the interfaces it implements; for an interface, the
+     *  classes that implement it. (ama-vtp) */
+    overrides: GraphNode[];
+    overriddenBy: GraphNode[];
+    interfaces: GraphNode[];
+    implementations: GraphNode[];
+    /** Other symbols that matched the same ref but weren't chosen as the primary —
+     *  so an ambiguous ref (e.g. "analyze" across an interface and its implementations)
+     *  surfaces its alternatives instead of silently hiding them. Empty when the ref
+     *  was unique. Pick one by its id/qualifiedName to inspect it directly. (ama-ceh) */
+    alternatives: GraphNode[];
+}
+/** A file's structure in one answer: the symbols it defines and what depends on
+ *  it — a structured, cheaper stand-in for reading the whole file. */
+export interface FileSkeleton {
+    /** The resolved File node. */
+    file: GraphNode;
+    /** Symbols the file defines, in source order (its outline). */
+    symbols: GraphNode[];
+    /** Files this file imports from — its outgoing dependencies, deduped to the file
+     *  level (find_imports has the per-symbol detail). Bounded by the file, so uncapped.
+     *  The symmetric counterpart to `dependents`. (ama-1jv) */
+    imports: GraphNode[];
+    /** Files that import (or re-export) this file — capped to keep the skeleton light.
+     *  See `dependentsTotal` for the full count, or use find_importers for the list. */
+    dependents: GraphNode[];
+    /** Total number of dependents (`dependents` may be a capped preview). (ama-2by) */
+    dependentsTotal: number;
+}
+/** A census of the graph's node and edge kinds — what the index actually contains. */
+export interface GraphSchema {
+    /** Count of nodes per kind (e.g. Class, Function, Method, Interface, File). */
+    nodes: Record<string, number>;
+    /** Count of edges per kind (e.g. Defines, Calls, Imports, Implements, UsesType). */
+    edges: Record<string, number>;
+    /** How many edges are checker-`resolved` vs `heuristic` (route/synthesized) vs
+     *  `dispatch` (interface/override fan-out) — edge-level tier honesty (ama-m8k.1,
+     *  ama-tr1). */
+    edgeProvenance: {
+        resolved: number;
+        heuristic: number;
+        dispatch: number;
+    };
+}
+/** A one-call overview of a question: matching symbols grouped by file, their
+ *  caller/callee relationships, and the combined transitive blast radius. */
+export interface Exploration {
+    question: string;
+    /** Top matching symbols (capped by the output budget), grouped by their file. */
+    byFile: Record<string, GraphNode[]>;
+    /** For each shown match: who calls it and what it calls. */
+    relationships: {
+        symbol: string;
+        callers: GraphNode[];
+        callees: GraphNode[];
+    }[];
+    /** Transitive callers of the shown matches — what changing them would affect
+     *  (capped by the output budget). */
+    blastRadius: GraphNode[];
+    /** Total matches before the budget cap — when > shown, refine the query. (ama-m8k.4) */
+    totalMatches: number;
+    /** Total blast-radius symbols before the budget cap. (ama-m8k.4) */
+    totalBlastRadius: number;
+}
+/** A search query split into free text and structured filters (ama-m8k.3). */
+export interface SearchQuery {
+    /** Free text matched against symbol name / qualified name. */
+    text: string;
+    /** File-path substring filter (`path:src/api`). */
+    path?: string;
+    /** Node-kind filter (`kind:Function`), matched case-insensitively. */
+    kind?: string;
+    /** Language filter (`lang:python`), derived from the file extension. */
+    lang?: string;
+    /** Explicit name-substring filter (`name:handler`), in addition to free text. */
+    name?: string;
+}
+/**
+ * Parse a search string into free text plus `path:`/`kind:`/`lang:`/`name:`
+ * filters, honouring quotes for values with spaces. Unknown `key:value` tokens
+ * (e.g. a `http://…` URL) are kept verbatim as free text rather than dropped.
+ */
+export declare function parseSearchQuery(raw: string): SearchQuery;
+/** Whether a path looks like a test file — `tests/`/`__tests__/` dirs or a
+ *  `.test.`/`.spec.` name. Used by test-impact filtering (ama-5gs.9) and search
+ *  demotion. */
+export declare function isTestFile(file: string): boolean;
+/** Default result cap for search_symbol/search_code — shared so the MCP layer can
+ *  request one extra and tell the agent when the result was truncated. (ama-b4q) */
+export declare const DEFAULT_SEARCH_LIMIT = 50;
+/** Cap on the secondary `dependents` preview in a file skeleton. The outline
+ *  (symbols) stays complete; dependents is bounded so a foundational file's skeleton
+ *  doesn't dwarf the file it summarizes — `dependentsTotal` carries the full count
+ *  and find_importers gives the complete list. (ama-2by) */
+export declare const SKELETON_DEPENDENTS_LIMIT = 25;
+/**
+ * Read-side of the graph: the four MVP questions an agent asks, answered from
+ * the store. A "symbol reference" is either an exact node id (e.g.
+ * "src/a.ts#Foo.bar") or a bare name ("bar"); names may resolve to several nodes.
+ */
+export declare class QueryService {
+    private readonly store;
+    /** Absolute repo root, used to read source for snippets. */
+    private readonly root;
+    constructor(store: Store, 
+    /** Absolute repo root, used to read source for snippets. */
+    root: string);
+    /**
+     * Symbols whose name matches `query`, answered by the store's name index
+     * (substring in-memory, FTS5 prefix in SQLite). Kind is filtered on top.
+     */
+    searchSymbol(query: string, opts?: SearchOptions): GraphNode[];
+    /**
+     * searchSymbol plus a confidence signal: low-confidence when there is a free-text
+     * term and results, but none is an exact or name-prefix match — the matches are
+     * loose substring/qualified hits, so the caller likely mistyped or should refine
+     * rather than trust the top hit. (ama-b79)
+     */
+    searchSymbolWithConfidence(query: string, opts?: SearchOptions): SearchResult;
+    /** Every indexed file's metadata, sorted by repo-relative path. */
+    files(): FileMeta[];
+    /**
+     * Full-text search over symbol *bodies* (not names): symbols whose verbatim
+     * source contains `query`, case-insensitively. Each file is read once and
+     * sliced per symbol; File nodes are excluded so a hit points at the containing
+     * symbol. This is the in-memory tier — a plain substring scan, not an FTS
+     * index (the SQLite store can specialize it later).
+     */
+    searchCode(query: string, opts?: {
+        limit?: number;
+    }): GraphNode[];
+    /** search_code that also reports whether it fell back from an exact-phrase match to
+     *  term-matching (the literal phrase wasn't found) — so the MCP layer can warn the
+     *  agent that the hits match the query's words separately, not the phrase. (ama-dve) */
+    searchCodeWithConfidence(query: string, opts?: {
+        limit?: number;
+    }): {
+        results: GraphNode[];
+        viaTerms: boolean;
+    };
+    private scanCode;
+    /** Symbols that call or construct the referenced symbol, each labelled by the
+     *  edge kind (`Calls` / `Instantiates`) and its call-site location. */
+    findCallers(ref: string): EdgeNeighbor[];
+    /** Symbols the referenced symbol calls or constructs, each labelled by the edge
+     *  kind (`Calls` / `Instantiates`) and its call-site location. */
+    findCallees(ref: string): EdgeNeighbor[];
+    /** The handler symbols a route refers to (route → References → handler). */
+    findHandlers(ref: string): EdgeNeighbor[];
+    /**
+     * Everything that points at a symbol via a References edge: the readers of a
+     * module-level Variable (ama-6k0), the routes that map to a handler (rme.1), and
+     * any other dispatch reference. The general "who refers to this" — answers the
+     * question `find_callers` can't, since reads aren't calls. (ama-pfm)
+     */
+    findReferrers(ref: string): EdgeNeighbor[];
+    /** The routes that map to a handler — the route-domain framing of
+     *  {@link findReferrers} (a route References its handler). */
+    findRoutes(ref: string): EdgeNeighbor[];
+    /** The supertype methods a method overrides or implements (method → super). */
+    findOverrides(ref: string): EdgeNeighbor[];
+    /** The subtype methods that override a method (who overrides this — incoming). */
+    findOverriddenBy(ref: string): EdgeNeighbor[];
+    /** Classes that implement the referenced interface. */
+    findImplementations(ref: string): GraphNode[];
+    /** Interfaces the referenced class implements. */
+    findInterfaces(ref: string): GraphNode[];
+    /** Edges representing an import of/by `id` — value (`Imports`) and type-only
+     *  (`ImportsType`) alike — so importer/dependent/affected queries still count an
+     *  `import type` (it's a compile-time dependency). (ama-bhf) */
+    private importEdgesTo;
+    private importEdgesFrom;
+    /** Files that import (or re-export) the referenced symbol. */
+    findImporters(ref: string): GraphNode[];
+    /** Symbols the referenced file imports (or re-exports). */
+    findImports(ref: string): GraphNode[];
+    /** Symbols that use the referenced type in a parameter, return, or property. */
+    findTypeUsers(ref: string): GraphNode[];
+    /** Types the referenced symbol uses in a parameter, return, or property. */
+    findTypesUsed(ref: string): GraphNode[];
+    /** The named types a symbol returns (function/method → its return type). */
+    findReturns(ref: string): GraphNode[];
+    /**
+     * Everything about one node in a single call: its definition plus full
+     * source, callers, callees, and dependents — a higher-order composition of
+     * the individual query methods so an agent gets the whole picture at once.
+     * Undefined when the ref resolves to nothing.
+     */
+    node(ref: string): NodeView | undefined;
+    /** The symbols a node directly defines — its `Defines` targets (a class's
+     *  methods/properties, an interface's members, …) — in source order. (ama-as5) */
+    private definedBy;
+    /**
+     * A file's skeleton: the symbols it defines (its outline, in source order) plus
+     * the files that depend on it — so an agent grasps a file's shape and reverse
+     * dependencies from one call instead of reading the whole file. `ref` is a File
+     * id (repo-relative path) or basename; non-file matches are ignored.
+     */
+    fileSkeleton(ref: string): FileSkeleton | undefined;
+    /**
+     * The transitive blast radius of a symbol: everything affected by changing it,
+     * found by walking the reverse dependency edges breadth-first (callers, type
+     * users, referrers, implementers, subclasses, …). `maxDepth` bounds the traversal
+     * (default unbounded); a visited set makes cycles and recursion safe. The seed
+     * symbol(s) the ref resolves to are excluded. Following every {@link
+     * IMPACT_EDGE_KINDS} edge — not just `Calls` — is what lets the blast radius of a
+     * type/interface/constant surface, since those are referenced, not called. (ama-8sw)
+     */
+    impactAnalysis(ref: string, maxDepth?: number): GraphNode[];
+    /**
+     * A census of the graph: how many nodes of each kind and edges of each kind
+     * the index holds. Each edge is counted once, at its source node.
+     */
+    getGraphSchema(): GraphSchema;
+    /**
+     * The files affected by changing the given files: the transitive set of files
+     * that import from them — directly (a module import) or by importing a symbol
+     * they define — walked breadth-first. The input files are excluded. Answers
+     * "which files (and tests) should I recheck?". Non-file refs and unknowns
+     * contribute nothing.
+     */
+    affected(refs: string[], opts?: {
+        testsOnly?: boolean;
+    }): GraphNode[];
+    /**
+     * Files that import from `fileId`: importers of the module itself (a star
+     * re-export or namespace import targets the File node) plus importers of each
+     * symbol the file defines.
+     */
+    private fileImporters;
+    /** The files this file imports: each Imports edge's target resolved to the file
+     *  it lives in (a File node's id is its path, so that file is the target). */
+    private fileImports;
+    /**
+     * File-level import cycles, each a strongly-connected component of two or more
+     * files that (transitively) import each other — the high-signal answer for
+     * untangling a module graph. Tarjan's SCC over the file import graph; a
+     * single-node component (no self-import) is not a cycle and is omitted. (ama-m8k.7)
+     */
+    circularImports(): GraphNode[][];
+    /**
+     * A one-call overview answering "what's going on around X?": symbols whose
+     * name matches `question`, grouped by file, each with its callers and callees,
+     * plus the combined transitive blast radius. Composes searchSymbol,
+     * findCallers/findCallees, and impactAnalysis — no new graph logic.
+     */
+    explore(question: string, opts?: {
+        limit?: number;
+    }): Exploration;
+    /** Search each term and union the hits, ranked by how many distinct terms a
+     *  symbol matches (a symbol hitting several is more on-topic), then by its best
+     *  per-term relevance position. Each per-term `searchSymbol` keeps its own
+     *  relevance order, so a single-term question behaves exactly as before. (ama-30q) */
+    private searchByTerms;
+    /** Verbatim source for a symbol, or undefined if it has no known location. */
+    getCodeSnippet(ref: string): Snippet | undefined;
+    /**
+     * Resolve a reference to node(s), most-specific first: exact id, then simple
+     * name (e.g. "compute"), then dotted qualified name (e.g. "Service.compute").
+     */
+    private resolve;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/query/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/query/service.ts"],"names":[],"mappings":"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"}