@abdulmunimjemal/codescope 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -200,6 +200,13 @@ declare class GraphStore {
         kind?: "call" | "method" | "import";
         limit?: number;
     }): RefRow[];
+    /**
+     * Files whose imports reference a module basename (e.g. `store` for
+     * `src/store.ts`). Matches `import … from "./store"`, `"../src/store.js"`,
+     * etc. Used by affected-test analysis to follow import edges, which — unlike
+     * call edges — reliably reach test files (tests import the module under test).
+     */
+    findImporters(moduleBasename: string): string[];
     /** The symbols defined in a file, in source order. */
     fileOutline(path: string): SymbolRow[];
     /** Distinct (callee, callKind) pairs invoked from inside symbols named `from`. */
@@ -298,11 +305,15 @@ declare function parseSource(langId: string, source: string): Promise<ParseResul
  * "member access" node — so definitions, calls, and imports are all described
  * declaratively here and interpreted by a single generic walker.
  */
-type NameStrategy = "field" | "c_declarator";
+type NameStrategy = "field" | "c_declarator" | "first_typed";
 interface DefRule {
     kind: SymbolKind;
-    /** How to read the definition's name (default: the `name` field). */
+    /** How to read the definition's name (default: `field` on `name`). */
     name?: NameStrategy;
+    /** For the `field` strategy: which field holds the name (default `name`). */
+    nameField?: string;
+    /** For the `first_typed` strategy: pick the first named child of these types. */
+    nameTypes?: string[];
 }
 interface CallRule {
     /** AST node type for this kind of call. */
@@ -360,13 +371,61 @@ declare function createServer(store: GraphStore): McpServer;
 /** Connect a codescope server to stdio (the transport coding agents speak). */
 declare function runStdioServer(store: GraphStore): Promise<void>;
 
+/** Whether a repo-relative path looks like a test file. */
+declare function isTestFile(path: string): boolean;
+interface AffectedResult {
+    changed: string[];
+    /** Every file that defines a symbol transitively affected by the changes. */
+    impactedFiles: string[];
+    /** The impacted files that look like tests — the suite worth re-running. */
+    tests: string[];
+}
+declare function affected(store: GraphStore, changedPaths: string[], opts?: {
+    depth?: number;
+}): AffectedResult;
+
+/** Agents whose config is plain JSON with an `mcpServers` map (auto-wirable). */
+type AgentId = "claude" | "cursor";
+declare const SUPPORTED_AGENTS: readonly AgentId[];
+interface ServerEntry {
+    command: string;
+    args: string[];
+}
+/** The MCP server entry agents need to launch codescope over stdio. */
+declare function serverEntry(serveTarget?: string): ServerEntry;
+/** The config file codescope writes for a given agent. */
+declare function configPath(agent: AgentId, root: string, global?: boolean): string;
+interface InstallOutcome {
+    agent: AgentId;
+    path: string;
+    action: "added" | "updated";
+}
+/**
+ * Idempotently wire codescope into an agent's MCP config. Preserves any other
+ * servers already configured and overwrites only the `codescope` entry.
+ */
+declare function installInto(agent: AgentId, root: string, opts?: {
+    global?: boolean;
+    serveTarget?: string;
+}): InstallOutcome;
+/** Wire codescope into one or more agents. */
+declare function install(root: string, opts?: {
+    agents?: AgentId[];
+    global?: boolean;
+    serveTarget?: string;
+}): InstallOutcome[];
+/** Copy-paste config for agents whose config isn't plain JSON (e.g. Codex, TOML). */
+declare function codexSnippet(serveTarget?: string): string;
+
 declare function formatSymbols(rows: SymbolRow[]): string;
 declare function formatRefs(rows: RefRow[]): string;
 declare function formatNeighborhood(n: Neighborhood): string;
 declare function formatImpact(rows: ImpactRow[]): string;
 declare function formatContext(b: ContextBundle): string;
+declare function formatAffected(r: AffectedResult): string;
 declare function formatStats(s: IndexStats): string;
 
+declare const format_formatAffected: typeof formatAffected;
 declare const format_formatContext: typeof formatContext;
 declare const format_formatImpact: typeof formatImpact;
 declare const format_formatNeighborhood: typeof formatNeighborhood;
@@ -374,10 +433,10 @@ declare const format_formatRefs: typeof formatRefs;
 declare const format_formatStats: typeof formatStats;
 declare const format_formatSymbols: typeof formatSymbols;
 declare namespace format {
-  export { format_formatContext as formatContext, format_formatImpact as formatImpact, format_formatNeighborhood as formatNeighborhood, format_formatRefs as formatRefs, format_formatStats as formatStats, format_formatSymbols as formatSymbols };
+  export { format_formatAffected as formatAffected, format_formatContext as formatContext, format_formatImpact as formatImpact, format_formatNeighborhood as formatNeighborhood, format_formatRefs as formatRefs, format_formatStats as formatStats, format_formatSymbols as formatSymbols };
 }
 
 /** The codescope version. Kept in sync with package.json at release time. */
-declare const VERSION = "0.2.0";
+declare const VERSION = "0.3.0";
 
-export { type ContextBundle, type FileIndexOutcome, type FileMeta, GraphStore, type ImpactRow, type IndexOptions, type IndexRunResult, type IndexStats, Indexer, LANGUAGES, type LanguageConfig, type Neighborhood, type ParseResult, type ParsedRef, type ParsedSymbol, type RefKind, type RefRow, SUPPORTED_EXTENSIONS, type SymbolKind, type SymbolRow, VERSION, type WatchEvents, type WatchHandle, type WatchOptions, createServer, format, languageForPath, parseSource, runStdioServer, watch };
+export { type AffectedResult, type AgentId, type ContextBundle, type FileIndexOutcome, type FileMeta, GraphStore, type ImpactRow, type IndexOptions, type IndexRunResult, type IndexStats, Indexer, type InstallOutcome, LANGUAGES, type LanguageConfig, type Neighborhood, type ParseResult, type ParsedRef, type ParsedSymbol, type RefKind, type RefRow, SUPPORTED_AGENTS, SUPPORTED_EXTENSIONS, type SymbolKind, type SymbolRow, VERSION, type WatchEvents, type WatchHandle, type WatchOptions, affected, codexSnippet, configPath, createServer, format, install, installInto, isTestFile, languageForPath, parseSource, runStdioServer, serverEntry, watch };

package/dist/index.js

@@ -307,6 +307,18 @@ var GraphStore = class {
     ).all(name, limit);
     return rows.map(toRefRow);
   }
+  /**
+   * Files whose imports reference a module basename (e.g. `store` for
+   * `src/store.ts`). Matches `import … from "./store"`, `"../src/store.js"`,
+   * etc. Used by affected-test analysis to follow import edges, which — unlike
+   * call edges — reliably reach test files (tests import the module under test).
+   */
+  findImporters(moduleBasename2) {
+    return this.db.prepare(
+      `SELECT DISTINCT f.path FROM refs r JOIN files f ON f.id = r.file_id
+         WHERE r.kind = 'import' AND (r.name = ? OR r.name LIKE ? OR r.name LIKE ?)`
+    ).all(moduleBasename2, `%/${moduleBasename2}`, `%/${moduleBasename2}.%`).map((r) => r.path);
+  }
   /** The symbols defined in a file, in source order. */
   fileOutline(path) {
     return this.db.prepare(
@@ -683,6 +695,118 @@ var php = {
   importRules: [{ type: "namespace_use_declaration", childTypes: ["namespace_use_clause"] }],
   exportTypes: /* @__PURE__ */ new Set()
 };
+var scala = {
+  id: "scala",
+  wasm: "scala",
+  defs: {
+    class_definition: { kind: "class" },
+    object_definition: { kind: "class" },
+    trait_definition: { kind: "interface" },
+    function_definition: { kind: "method" },
+    type_definition: { kind: "type" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [
+    { type: "call_expression", fnField: "function", memberTypes: ["field_expression"], memberField: "field" }
+  ],
+  importRules: [{ type: "import_declaration", childTypes: ["stable_identifier", "identifier"] }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var solidity = {
+  id: "solidity",
+  wasm: "solidity",
+  defs: {
+    contract_declaration: { kind: "class" },
+    interface_declaration: { kind: "interface" },
+    library_declaration: { kind: "class" },
+    function_definition: { kind: "method" },
+    modifier_definition: { kind: "function" },
+    struct_declaration: { kind: "class" },
+    enum_declaration: { kind: "enum" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [{ type: "call_expression", fnField: "function" }],
+  importRules: [{ type: "import_directive", field: "source" }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var zig = {
+  id: "zig",
+  wasm: "zig",
+  defs: { function_declaration: { kind: "function" } },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [{ type: "call_expression", fnField: "function" }],
+  importRules: [],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var kotlin = {
+  id: "kotlin",
+  wasm: "kotlin",
+  defs: {
+    class_declaration: { kind: "class", name: "first_typed", nameTypes: ["type_identifier"] },
+    object_declaration: { kind: "class", name: "first_typed", nameTypes: ["type_identifier"] },
+    function_declaration: { kind: "function", name: "first_typed", nameTypes: ["simple_identifier"] }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: true,
+  callRules: [],
+  importRules: [{ type: "import_header", childTypes: ["identifier"] }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var objc = {
+  id: "objc",
+  wasm: "objc",
+  defs: {
+    class_interface: { kind: "class", name: "first_typed", nameTypes: ["identifier"] },
+    class_implementation: { kind: "class", name: "first_typed", nameTypes: ["identifier"] },
+    method_declaration: { kind: "method", name: "first_typed", nameTypes: ["identifier"] },
+    method_definition: { kind: "method", name: "first_typed", nameTypes: ["identifier"] }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [{ type: "call_expression", fnField: "function" }],
+  importRules: [{ type: "preproc_include", field: "path" }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var lua = {
+  id: "lua",
+  wasm: "lua",
+  defs: {
+    function_definition_statement: { kind: "function" },
+    local_function_definition_statement: { kind: "function" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [],
+  importRules: [],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var bash = {
+  id: "bash",
+  wasm: "bash",
+  defs: { function_definition: { kind: "function" } },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [],
+  importRules: [],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var ocaml = {
+  id: "ocaml",
+  wasm: "ocaml",
+  defs: {
+    let_binding: { kind: "function", name: "field", nameField: "pattern" },
+    module_definition: { kind: "class" },
+    type_definition: { kind: "type" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [],
+  importRules: [],
+  exportTypes: /* @__PURE__ */ new Set()
+};
 var LANGUAGES = {
   typescript,
   tsx,
@@ -695,7 +819,15 @@ var LANGUAGES = {
   c,
   cpp,
   csharp,
-  php
+  php,
+  scala,
+  solidity,
+  zig,
+  kotlin,
+  objc,
+  lua,
+  bash,
+  ocaml
 };
 var EXT_TO_LANG = {
   ".ts": "typescript",
@@ -720,7 +852,19 @@ var EXT_TO_LANG = {
   ".hpp": "cpp",
   ".hh": "cpp",
   ".cs": "csharp",
-  ".php": "php"
+  ".php": "php",
+  ".scala": "scala",
+  ".sc": "scala",
+  ".sol": "solidity",
+  ".zig": "zig",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".m": "objc",
+  ".lua": "lua",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".ml": "ocaml",
+  ".mli": "ocaml"
 };
 var SUPPORTED_EXTENSIONS = Object.keys(EXT_TO_LANG);
 function languageForPath(path) {
@@ -806,7 +950,7 @@ function classify(node, lang) {
   return null;
 }
 function buildSymbol(node, rule, container, containerKind, lang) {
-  const name = symbolName(node, rule.name ?? "field");
+  const name = symbolName(node, rule);
   if (!name) return null;
   let kind = rule.kind;
   if (kind === "function" && lang.nestedFunctionsAreMethods && containerKind === "class") {
@@ -826,9 +970,20 @@ function buildSymbol(node, rule, container, containerKind, lang) {
     endByte: node.endIndex
   };
 }
-function symbolName(node, strategy) {
-  if (strategy === "c_declarator") return cDeclaratorName(node);
-  return node.childForFieldName("name")?.text ?? null;
+function symbolName(node, rule) {
+  switch (rule.name ?? "field") {
+    case "c_declarator":
+      return cDeclaratorName(node);
+    case "first_typed": {
+      const types = rule.nameTypes ?? [];
+      for (const child of node.namedChildren) {
+        if (types.includes(child.type)) return child.text;
+      }
+      return null;
+    }
+    default:
+      return node.childForFieldName(rule.nameField ?? "name")?.text ?? null;
+  }
 }
 function cDeclaratorName(node) {
   let decl = node.childForFieldName("declarator");
@@ -1073,9 +1228,62 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 
+// src/affected.ts
+var TEST_PATTERNS = [
+  /(^|\/)(tests?|spec|specs|__tests__|e2e|integration)\//i,
+  /\.(test|spec)\.[a-z]+$/i,
+  // foo.test.ts, foo.spec.js
+  /_test\.[a-z]+$/i,
+  // foo_test.go, foo_test.py, foo_test.rs
+  /(^|\/)test_[^/]+\.(py|rb)$/i,
+  // test_foo.py
+  /(Test|Tests|Spec)\.[a-z]+$/i,
+  // FooTest.java, FooTests.cs, FooSpec.scala
+  /_spec\.rb$/i
+  // foo_spec.rb
+];
+function isTestFile(path) {
+  return TEST_PATTERNS.some((re) => re.test(path));
+}
+function moduleBasename(path) {
+  const base = path.slice(path.lastIndexOf("/") + 1);
+  const dot = base.indexOf(".");
+  return dot === -1 ? base : base.slice(0, dot);
+}
+function affected(store, changedPaths, opts = {}) {
+  const depth = opts.depth ?? 4;
+  const impactedFiles = new Set(changedPaths);
+  for (const path of changedPaths) {
+    for (const sym of store.fileOutline(path)) {
+      for (const caller of store.impact(sym.name, { depth })) {
+        impactedFiles.add(caller.file);
+      }
+    }
+  }
+  let frontier = [...changedPaths];
+  for (let d = 0; d < depth && frontier.length > 0; d++) {
+    const next = [];
+    for (const path of frontier) {
+      for (const importer of store.findImporters(moduleBasename(path))) {
+        if (!impactedFiles.has(importer)) {
+          impactedFiles.add(importer);
+          next.push(importer);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return {
+    changed: changedPaths,
+    impactedFiles: [...impactedFiles].sort(),
+    tests: [...impactedFiles].filter(isTestFile).sort()
+  };
+}
+
 // src/format.ts
 var format_exports = {};
 __export(format_exports, {
+  formatAffected: () => formatAffected,
   formatContext: () => formatContext,
   formatImpact: () => formatImpact,
   formatNeighborhood: () => formatNeighborhood,
@@ -1137,6 +1345,14 @@ function formatContext(b) {
   }
   return lines.join("\n");
 }
+function formatAffected(r) {
+  if (r.tests.length === 0) {
+    return `No test files appear affected by ${r.changed.length} changed file(s).`;
+  }
+  const lines = [`${r.tests.length} test file(s) affected by your changes:`, ""];
+  for (const t of r.tests) lines.push(`  ${t}`);
+  return lines.join("\n");
+}
 function formatStats(s) {
   const kinds = Object.entries(s.byKind).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k}=${n}`).join(" ");
   const langs = Object.entries(s.byLang).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k}=${n}`).join(" ");
@@ -1149,7 +1365,7 @@ function formatStats(s) {
 }
 
 // src/version.ts
-var VERSION = "0.2.0";
+var VERSION = "0.3.0";
 
 // src/mcp.ts
 var KIND = z.enum(["function", "method", "class", "interface", "type", "enum", "variable"]);
@@ -1269,6 +1485,18 @@ function createServer(store) {
     },
     async ({ name, depth, limit }) => textResult(formatNeighborhood(store.neighborhood(name, { depth, limit })))
   );
+  server.registerTool(
+    "affected",
+    {
+      title: "Affected tests",
+      description: "Given a list of changed files, return the test files likely affected \u2014 the symbols those files define, walked through their transitive callers, filtered to tests. Use before running a suite to know what's worth re-running.",
+      inputSchema: {
+        files: z.array(z.string()).describe("repo-relative paths of the changed files"),
+        depth: z.number().int().min(1).max(6).optional()
+      }
+    },
+    async ({ files, depth }) => textResult(formatAffected(affected(store, files, { depth })))
+  );
   server.registerTool(
     "stats",
     {
@@ -1285,17 +1513,77 @@ async function runStdioServer(store) {
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
+
+// src/install.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var PACKAGE = "@abdulmunimjemal/codescope";
+var MCP_SERVER_NAME = "codescope";
+var SUPPORTED_AGENTS = ["claude", "cursor"];
+function serverEntry(serveTarget = ".") {
+  return { command: "npx", args: ["-y", PACKAGE, "mcp", serveTarget] };
+}
+function configPath(agent, root, global = false) {
+  switch (agent) {
+    case "claude":
+      return global ? join(homedir(), ".mcp.json") : join(root, ".mcp.json");
+    case "cursor":
+      return global ? join(homedir(), ".cursor", "mcp.json") : join(root, ".cursor", "mcp.json");
+  }
+}
+function readJson(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function installInto(agent, root, opts = {}) {
+  const path = configPath(agent, root, opts.global ?? false);
+  const config = readJson(path);
+  const existing = config.mcpServers;
+  const servers = existing && typeof existing === "object" ? existing : {};
+  const existed = Object.prototype.hasOwnProperty.call(servers, MCP_SERVER_NAME);
+  servers[MCP_SERVER_NAME] = serverEntry(opts.serveTarget);
+  config.mcpServers = servers;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+  return { agent, path, action: existed ? "updated" : "added" };
+}
+function install(root, opts = {}) {
+  const agents = opts.agents ?? [...SUPPORTED_AGENTS];
+  return agents.map((agent) => installInto(agent, root, opts));
+}
+function codexSnippet(serveTarget = ".") {
+  return [
+    "[mcp_servers.codescope]",
+    'command = "npx"',
+    `args = ["-y", "${PACKAGE}", "mcp", "${serveTarget}"]`
+  ].join("\n");
+}
 export {
   GraphStore,
   Indexer,
   LANGUAGES,
+  SUPPORTED_AGENTS,
   SUPPORTED_EXTENSIONS,
   VERSION,
+  affected,
+  codexSnippet,
+  configPath,
   createServer,
   format_exports as format,
+  install,
+  installInto,
+  isTestFile,
   languageForPath,
   parseSource,
   runStdioServer,
+  serverEntry,
   watch
 };
 //# sourceMappingURL=index.js.map