@mka-rainmaker/ama 0.1.0

package/dist/analyzers/sidecar/protocol.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { EDGE_KINDS, NODE_KINDS } from "../../graph/index.js";
+/**
+ * Wire protocol for out-of-process deep analyzers ("sidecars"). (ama-3bb.1)
+ *
+ * A sidecar is a subprocess that does semantic analysis for a language Ama can't
+ * analyze deeply in-process (.NET via Roslyn, Java via native tooling) and speaks this
+ * protocol back. The contract here is language-agnostic; each sidecar implements its own
+ * end in its own runtime.
+ *
+ * **Transport.** Newline-delimited JSON (NDJSON): one JSON object per line. Ama writes
+ * requests to the sidecar's **stdin** and reads messages from its **stdout**. The
+ * sidecar's **stderr** is for its own logs only — never protocol — exactly the
+ * "stdout is JSON-only" rule Ama's own MCP server follows.
+ *
+ * **Lifecycle.** On startup a sidecar SHOULD emit a `ready` message announcing the
+ * language it serves (so the indexer can route and report it). Ama then sends `analyze`
+ * requests; the sidecar replies with a `result` (correlated by the request `id`) or an
+ * `error`. Ama closes the sidecar's stdin to request shutdown.
+ *
+ * **Tier.** Everything a sidecar produces is tier `deep` — that is the whole point of
+ * running one instead of the baseline syntactic analyzer.
+ */
+const tierSchema = z.enum(["deep", "baseline"]);
+const provenanceSchema = z.enum(["resolved", "heuristic", "dispatch"]);
+const sourceRangeSchema = z.object({ startLine: z.number(), endLine: z.number() });
+const siteSchema = z.object({ line: z.number(), column: z.number() });
+/** A {@link GraphNode} on the wire. Kept in lockstep with the graph model; the node/edge
+ *  round-trip test fails if a required field drifts. */
+export const graphNodeSchema = z.object({
+    id: z.string(),
+    kind: z.enum(NODE_KINDS),
+    name: z.string(),
+    file: z.string(),
+    qualifiedName: z.string(),
+    range: sourceRangeSchema.optional(),
+    tier: tierSchema,
+});
+/** A {@link GraphEdge} on the wire. */
+export const graphEdgeSchema = z.object({
+    from: z.string(),
+    to: z.string(),
+    kind: z.enum(EDGE_KINDS),
+    provenance: provenanceSchema.optional(),
+    at: siteSchema.optional(),
+    sites: z.array(siteSchema).optional(),
+});
+const resolutionStatsSchema = z.object({
+    callsTotal: z.number(),
+    callsResolved: z.number(),
+    unresolved: z.record(z.string(), z.number()),
+});
+/** Ama → sidecar: analyze these repo-relative `files` rooted at the absolute `root`.
+ *  `id` correlates the matching `result`/`error`. */
+export const analyzeRequestSchema = z.object({
+    type: z.literal("analyze"),
+    id: z.number(),
+    root: z.string(),
+    files: z.array(z.string()),
+});
+/** Sidecar → Ama: a startup handshake announcing the language served. */
+const readySchema = z.object({
+    type: z.literal("ready"),
+    language: z.string(),
+    version: z.string().optional(),
+});
+/** Sidecar → Ama: the analysis of one request's files. */
+const resultSchema = z.object({
+    type: z.literal("result"),
+    id: z.number(),
+    nodes: z.array(graphNodeSchema),
+    edges: z.array(graphEdgeSchema),
+    resolution: resolutionStatsSchema.optional(),
+});
+/** Sidecar → Ama: a failure, optionally tied to a request `id`. */
+const errorSchema = z.object({
+    type: z.literal("error"),
+    id: z.number().optional(),
+    message: z.string(),
+});
+/** Any message a sidecar sends to Ama. */
+export const sidecarMessageSchema = z.discriminatedUnion("type", [
+    readySchema,
+    resultSchema,
+    errorSchema,
+]);
+/** Encode a protocol message as one NDJSON line (its JSON, plus the framing newline).
+ *  Used by both ends; a message must contain no raw newline of its own (JSON escapes them). */
+export function frame(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+/** Parse one inbound line as an `analyze` request (the sidecar's side). Throws (ZodError
+ *  or SyntaxError) on a malformed or invalid line. */
+export function parseRequest(line) {
+    return analyzeRequestSchema.parse(JSON.parse(line));
+}
+/** Parse one inbound line as a sidecar message (Ama's side). Throws on a malformed or
+ *  invalid line, so a buggy sidecar can't inject an ill-formed node/edge into the graph. */
+export function parseMessage(line) {
+    return sidecarMessageSchema.parse(JSON.parse(line));
+}
+//# sourceMappingURL=protocol.js.map

package/dist/analyzers/sidecar/protocol.js.map

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

package/dist/analyzers/types.d.ts

@@ -0,0 +1,46 @@
+import type { GraphEdge, GraphNode, Tier } from "../graph/index.js";
+/** How many references an analyzer tried to resolve vs actually resolved — the
+ *  basis for an honest "resolution coverage" metric. (ama-m8k.12) */
+export interface ResolutionStats {
+    /** Call/construction sites inside a function (those that can become an edge). */
+    callsTotal: number;
+    /** Of those, how many resolved to a known target node (the rest are external
+     *  or dynamic — library calls, computed dispatch). */
+    callsResolved: number;
+    /** The unresolved calls, counted by callee root name (e.g. `ts`, `console`,
+     *  `path`) — what the code calls that Ama can't see. (ama-qbn) */
+    unresolved: Record<string, number>;
+}
+/** Nodes and edges produced by analyzing a set of files. */
+export interface AnalysisResult {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    /** Resolution coverage, when the analyzer measures it. Deep analyzers report
+     *  it; a baseline (syntactic) analyzer resolves nothing, so it omits this. */
+    resolution?: ResolutionStats;
+}
+/**
+ * A per-language analyzer. Each declares its capability {@link Tier} so every
+ * result can be attributed honestly: a `baseline` (syntactic) analyzer must
+ * never be mistaken for `deep` (semantic) coverage.
+ */
+export interface Analyzer {
+    /** Human-readable language name, e.g. "typescript". */
+    readonly language: string;
+    /** Capability tier this analyzer reports. */
+    readonly tier: Tier;
+    /** File extensions this analyzer handles, including the dot, e.g. [".ts"]. */
+    readonly extensions: readonly string[];
+    /**
+     * Analyze `files` (repo-relative paths) rooted at the absolute `root`,
+     * returning the nodes and edges they define.
+     */
+    analyze(root: string, files: string[]): AnalysisResult | Promise<AnalysisResult>;
+    /**
+     * Whether this analyzer can actually run right now. In-process analyzers omit it
+     * (always available); an out-of-process sidecar probes its subprocess so routing can
+     * prefer it only when present, falling back to baseline otherwise. (ama-3bb.4)
+     */
+    isAvailable?(): boolean | Promise<boolean>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/analyzers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/analyzers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEpE;qEACqE;AACrE,MAAM,WAAW,eAAe;IAC9B,iFAAiF;IACjF,UAAU,EAAE,MAAM,CAAC;IACnB;0DACsD;IACtD,aAAa,EAAE,MAAM,CAAC;IACtB;sEACkE;IAClE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,4DAA4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB;kFAC8E;IAC9E,UAAU,CAAC,EAAE,eAAe,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,uDAAuD;IACvD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAEjF;;;;OAIG;IACH,WAAW,CAAC,IAAI,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC5C"}

package/dist/analyzers/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/analyzers/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/analyzers/types.ts"],"names":[],"mappings":""}

package/dist/analyzers/typescript/analyzer.d.ts

@@ -0,0 +1,126 @@
+import type { AnalysisResult, Analyzer } from "../types.js";
+/**
+ * Deep TypeScript analyzer built on the TypeScript Compiler API.
+ *
+ * Two passes over each source file:
+ *  1. Structural — emit nodes (File, Function, Class, Interface, Enum, TypeAlias,
+ *     Method, Property — see `describe` for the full set) and `Defines` edges,
+ *     recording each declaration's AST node so later references link back to ids.
+ *  2. Resolution — through the type checker, emit `Calls` edges (enclosing
+ *     function/method → callee), `Inherits`/`Implements` edges (class → base
+ *     class / interface), `UsesType` edges (enclosing symbol → each named type
+ *     used in a parameter, return, or property annotation), and `Imports` edges
+ *     (file → each symbol it imports or re-exports). References to symbols
+ *     outside the analyzed set (library code) resolve to no node and are
+ *     skipped, so the graph only asserts edges it can actually back.
+ */
+export declare class TypeScriptAnalyzer implements Analyzer {
+    readonly language = "typescript";
+    readonly tier: "deep";
+    readonly extensions: readonly [".ts", ".tsx", ".mts", ".cts"];
+    analyze(root: string, files: string[]): AnalysisResult;
+    private walkFile;
+    private visit;
+    /** Walk a subtree, attributing each call to the nearest enclosing symbol — or,
+     *  for a call at true module scope, to the File node so module-level wiring is
+     *  queryable. `atFileScope` is true until the walk enters any function body.
+     *  (ama-53q) */
+    private collectCalls;
+    /**
+     * Emit a `References` edge from the enclosing symbol to a module-level Variable
+     * node (ama-hft.12) each time its value is read — so `find_callers("MAX_RETRIES")`
+     * answers "who reads this constant". Mirrors `collectCalls`' enclosing-tracking.
+     *
+     * `resolveModuleVarRef` restricts targets to top-level const/let/var
+     * declarations (by *decl kind*, not a batch-local id set), so reads of
+     * functions/classes don't become References — and a cross-file const still
+     * resolves in a single-file reindex, where the batch holds no other file's
+     * Variable nodes (ama-l6k). Most false positives filter themselves out: a
+     * property-access member name and an import specifier resolve away, and a
+     * declaration's own name is caught by the `to !== enclosingId` guard. (ama-6k0)
+     */
+    private collectVarReferences;
+    /** Walk a subtree emitting an `Implements` edge for each `class … implements I`. */
+    private collectHeritage;
+    /**
+     * Emit an `Imports` edge from a file to each symbol it imports, and from a
+     * re-exporting file (`export { x } from "./m.js"`) to the re-exported symbol.
+     * Import/re-export bindings are aliases, so the edge target is the symbol's
+     * original declaration — even through a chain of barrels.
+     */
+    private collectImports;
+    /**
+     * Emit a `UsesType` edge for each named type referenced in a parameter, a
+     * function/method return type, a property type, or a generic instantiation's
+     * type arguments (`f<Widget>()`, `new Box<Widget>()`, `extends Base<Widget>`),
+     * attributed to the nearest enclosing emitted symbol. Composite annotations are
+     * walked, so `Widget[]` or `Map<K, Widget>` still link to `Widget`. Types
+     * outside the analyzed set (`number`, library types) resolve to no node and are
+     * skipped.
+     */
+    private collectTypeUsages;
+    /**
+     * Detect framework routes (Express/NestJS-style call APIs: `app.get("/x", h)`,
+     * `router.post(...)`) and emit a Route node per route, plus a References edge to
+     * each named handler. Deliberately scoped to avoid false positives: an HTTP-verb
+     * method call whose first arg is a "/"-prefixed string literal and which has at
+     * least one handler arg (so `map.get("k")` / `headers.get("x")` don't match).
+     * Inline arrow/function handlers get a Route node but no edge yet — naming an
+     * anonymous handler is the arg-position-handler follow-up (ama-y9q).
+     */
+    private collectRoutes;
+    /**
+     * Wire a route to its handler argument(s): an inline arrow/function becomes a
+     * synthesized handler Function node (named by the route, registered so its body
+     * attributes to it), while a named handler reference resolves to its node. Each
+     * gets a heuristic References edge from the route. Shared by every route style.
+     * (ama-rme.1, ama-rme.10)
+     */
+    private emitRouteHandlers;
+    /**
+     * Synthesize a Function node for an inline arrow/function-expression passed as an
+     * argument to a *string-named* call whose result is itself consumed —
+     * `register("work", wrap("work", () => …))`. The leading string literal names the
+     * node (`"work handler"`); registering the arrow in `declToId` before
+     * `collectCalls` makes the callback body's calls attribute to it instead of
+     * leaking to the enclosing function (so per-handler blast radius is precise).
+     *
+     * Runs after `collectRoutes`, so a route's inline handler — already registered —
+     * is skipped. The "result is consumed" gate (the call is not a bare expression
+     * statement) is what separates a handler-producing wrapper like `tap(name, fn)`
+     * from a fire-and-forget test block like `it(name, fn)` / `describe(name, fn)`:
+     * only the former becomes a node, so the graph isn't flooded with one node per
+     * test case. (ama-y9q)
+     *
+     * The handler need not be a *direct* argument: it may be nested inside a second
+     * wrapper whose own first argument is not a string — `tap("search",
+     * queryTool(session, () => …))`. `collectHandlerArrows` digs through such
+     * wrapper-call arguments (stopping at the first function, so a handler's body is
+     * never mistaken for another handler), keying every one by the outer name. (ama-63x)
+     */
+    private collectCallbackHandlers;
+    /**
+     * File-based routing: a route file at a framework convention path exports HTTP
+     * method handlers and the URL comes from the *path* (not a call). Next.js App
+     * Router (`app/**​/route.ts`) and SvelteKit (`src/routes/**​/+server.ts`) — each
+     * exported `GET`/`POST`/… function becomes a `<METHOD> <path>` Route referencing
+     * it. Heuristic: the route is inferred from filesystem convention. (ama-rme.7)
+     */
+    private collectFileRoutes;
+    /**
+     * Synthesize call edges for the EventEmitter pattern: an `emitter.emit("ch")`
+     * invokes every handler registered with `.on("ch", h)` (or once/addListener)
+     * for the same channel string. Heuristic — matched by channel name, not proven
+     * dispatch — so the synthesized edges carry `provenance: "heuristic"`. Runs
+     * after collectCallbackHandlers so inline `.on("ch", () => …)` arrows (already
+     * synthesized into handler nodes there) are connectable too. (ama-hft.14)
+     */
+    private collectEvents;
+    /**
+     * Find Express mounts — `app.use("/prefix", router, …)` — and map each mounted
+     * argument's declaration to the prefix. Runs over every file before route
+     * detection so a router defined in one file and mounted in another composes.
+     */
+    private collectMounts;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzers/typescript/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../../src/analyzers/typescript/analyzer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAmB,MAAM,aAAa,CAAC;AAkB7E;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAmB,YAAW,QAAQ;IACjD,QAAQ,CAAC,QAAQ,gBAAgB;IACjC,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAChC,QAAQ,CAAC,UAAU,2CAA4C;IAE/D,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,cAAc;IA+FtD,OAAO,CAAC,QAAQ;IAyBhB,OAAO,CAAC,KAAK;IAqHb;;;oBAGgB;IAChB,OAAO,CAAC,YAAY;IAoGpB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,oBAAoB;IA6D5B,oFAAoF;IACpF,OAAO,CAAC,eAAe;IAqBvB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAkDtB;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;IAkEzB;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAoOrB;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAsCzB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,uBAAuB;IA6D/B;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IA8FzB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IA0ErB;;;;OAIG;IACH,OAAO,CAAC,aAAa;CA0BtB"}