@youichi/repograph 0.1.0 → 0.1.1

package/README.md

@@ -17,13 +17,13 @@ The project pins `codebase-memory-mcp@0.12.1`. The initial installation download
 Run these commands from any directory:
 
 ```bash
-# Export all nodes and relationships: functions, files, modules, calls, imports, inheritance, etc.
+# Export all indexed nodes and relationships, plus source-derived class members and dependencies
 npx @youichi/repograph export ../anureo-sdk
 
 # Specify an output file
 npx @youichi/repograph export /path/to/repository --out .repograph/repository.json
 
-# Keep only CALLS edges, functions, methods, and the endpoints of those edges
+# Export only CALLS edges, functions/methods, and their endpoints
 npx @youichi/repograph export ../anureo-sdk --kind calls --out .repograph/calls.json
 
 # Show available options
@@ -35,7 +35,7 @@ The default output is `.repograph/graph.json` under the current working director
 | Option | Default | Purpose |
 | --- | --- | --- |
 | `--out`, `-o` | `.repograph/graph.json` | JSON output path |
-| `--kind` | `all` | `all` exports all relationships; `calls` exports the call graph |
+| `--kind` | `all` | `all` includes class structure and dependencies; `calls` keeps only direct call relationships |
 | `--project` | Directory name + hash of the absolute path | Override the upstream index name |
 | `--page-size` | `500` | Rows per query batch, from 1 to 10000 |
 
@@ -86,10 +86,37 @@ The following is a simplified example. Actual properties depend on the language
 }
 ```
 
-Node IDs and edge IDs are strings in separate namespaces. An edge's `source` and `target` refer to node IDs. IDs link records within the current export and are not guaranteed to remain stable across indexing runs. `indexReport` preserves the upstream indexing report; its counts still describe the original complete index in `calls` mode.
+Node IDs and edge IDs are strings in separate namespaces. An edge's `source` and `target` refer to node IDs. IDs link records within the current export and are not guaranteed to remain stable across indexing runs. `indexReport` preserves the upstream indexing report; its counts describe the upstream index and can differ from the exported graph after filtering or adding source-derived class data.
 
 TypeScript and JavaScript `Function` and `Method` nodes include `callable` metadata in both `all` and `calls` exports. The exporter parses upstream `properties.signature` and `properties.return_type` with the TypeScript parser, without loading the target project's dependencies or inferring types. Supported file extensions are `.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, and `.cjs`. Other languages and node labels omit `callable`. The original `properties` remain intact, and this additive field retains `schemaVersion: 1`.
 
+In `all` exports, TypeScript and JavaScript `Class` and `Interface` nodes include a `members` array for declared fields and accessors. Entries retain declared type text (or `null` when absent), source lines, visibility, static, optional, and readonly flags. The exporter also adds `DEPENDS_ON` edges for resolvable field, method-parameter, and method-return type references, plus method calls between classes. These source-derived edges have `properties.derivedFrom: "typescript-ast"` and a `reason`; they are omitted when a referenced class cannot be resolved without ambiguity. `calls` exports intentionally omit these class members and dependencies. Other languages retain whatever class, field, inheritance, implementation, and dependency nodes and edges the upstream indexer supplies.
+
+For example, `Customer` with an `address?: Address` field and a `save(input: Address): Result` method includes:
+
+```json
+{
+  "labels": ["Class"],
+  "name": "Customer",
+  "members": [
+    {
+      "name": "address",
+      "kind": "field",
+      "type": "Address",
+      "filePath": "model.ts",
+      "startLine": 6,
+      "endLine": 6,
+      "visibility": "public",
+      "static": false,
+      "optional": true,
+      "readonly": false
+    }
+  ]
+}
+```
+
+The graph also contains edges such as `{ "source": "<Customer id>", "target": "<Address id>", "type": "DEPENDS_ON", "properties": { "derivedFrom": "typescript-ast", "reason": "field-type", "member": "address" } }`. Existing upstream `INHERITS` and `IMPLEMENTS` edges are retained as-is.
+
 For example, `function load(id: string, count = 1, ...tags: string[]): Promise<string[]>` produces:
 
 ```json
@@ -140,11 +167,16 @@ bun run test:integration
 
 Unit tests cover pagination, cursors, truncation handling, file line counts, and structured callable metadata. The integration test uses the real native backend to index a temporary TypeScript project, checks cross-file calls, isolated functions, parameter and return annotations, methods, and export counts, and cleans up its temporary index.
 
+## Publishing
+
+Releases are published from GitHub Actions when a version tag is pushed. Before the first release, configure npm Trusted Publishing for package `@youichi/repograph` with GitHub user `hi-youichi`, repository `repograph`, and workflow file `publish-npm.yml`; allow direct `npm publish` for that publisher. Then update `package.json` to the new version and push the matching tag, for example `v0.1.1`. The workflow checks that the tag matches the package version, installs dependencies, runs typecheck and unit tests, then builds and publishes with npm provenance. No npm token is stored in GitHub Secrets.
+
 ## Limitations
 
 - Exports contain the static relationships actually indexed upstream and do not guarantee coverage of all runtime calls. Support for reflection, dynamic dispatch, and framework conventions varies by language.
 - The upstream indexer skips `node_modules`, files matching ignore rules, and other excluded inputs. Use the skip and parse counts in `indexReport` to assess coverage.
 - `calls` mode retains only `CALLS` edges. It does not treat `CALL_REFERENCE` or `USAGE` as direct calls. The upstream analyzer may also record recursion in properties while omitting self-call edges.
+- Source-derived class members and type dependencies currently cover TypeScript and JavaScript files. Other languages depend on the class, field, and relationship data available from the pinned upstream indexer; type references are not inferred from unannotated initializers.
 - Keep source files and the project's index unchanged during export, and prevent other processes from rebuilding the index concurrently. Exports are not transactional snapshots across queries.
 - Results are assembled in memory before being written to disk. Large repositories require sufficient memory, and upstream evaluation limits cause an error.
 - Place output outside the target repository to prevent a later indexing run from treating exported files as input. Upstream indexes remain in the local cache.

package/dist/classes.js

@@ -0,0 +1,192 @@
+// src/classes.ts
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { extname, resolve } from "node:path";
+import ts from "typescript";
+var CLASS_LABELS = new Set(["Class", "Interface", "Struct", "Trait"]);
+var SCRIPT_KINDS = {
+  ".ts": ts.ScriptKind.TS,
+  ".tsx": ts.ScriptKind.TSX,
+  ".mts": ts.ScriptKind.TS,
+  ".cts": ts.ScriptKind.TS,
+  ".js": ts.ScriptKind.JS,
+  ".jsx": ts.ScriptKind.JSX,
+  ".mjs": ts.ScriptKind.JS,
+  ".cjs": ts.ScriptKind.JS
+};
+function modifiers(node) {
+  return ts.canHaveModifiers(node) ? ts.getModifiers(node) ?? [] : [];
+}
+function memberName(name) {
+  if (!name)
+    return;
+  if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name))
+    return name.text;
+  if (ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+    return name.text;
+  if (ts.isComputedPropertyName(name) && (ts.isStringLiteral(name.expression) || ts.isNumericLiteral(name.expression)))
+    return name.expression.text;
+  return;
+}
+function typeNames(type, into = new Set) {
+  const visit = (node) => {
+    if (ts.isTypeReferenceNode(node)) {
+      const name = node.typeName.getText().split(".").at(-1);
+      if (name)
+        into.add(name);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(type);
+  return into;
+}
+function sourceLine(file, node) {
+  return file.getLineAndCharacterOfPosition(node.getStart(file)).line + 1;
+}
+function sourceEndLine(file, node) {
+  return file.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
+}
+function toMember(file, filePath, node) {
+  if (!ts.isPropertyDeclaration(node) && !ts.isPropertySignature(node) && !ts.isGetAccessorDeclaration(node) && !ts.isSetAccessorDeclaration(node))
+    return;
+  const name = memberName(node.name);
+  if (name === undefined)
+    return;
+  const flags = modifiers(node);
+  const visibility = flags.some((flag) => flag.kind === ts.SyntaxKind.PrivateKeyword) || name.startsWith("#") ? "private" : flags.some((flag) => flag.kind === ts.SyntaxKind.ProtectedKeyword) ? "protected" : "public";
+  const kind = ts.isGetAccessorDeclaration(node) ? "getter" : ts.isSetAccessorDeclaration(node) ? "setter" : "field";
+  return {
+    name,
+    kind,
+    type: node.type?.getText(file) ?? null,
+    filePath,
+    startLine: sourceLine(file, node),
+    endLine: sourceEndLine(file, node),
+    visibility,
+    static: flags.some((flag) => flag.kind === ts.SyntaxKind.StaticKeyword),
+    optional: !!node.questionToken,
+    readonly: flags.some((flag) => flag.kind === ts.SyntaxKind.ReadonlyKeyword)
+  };
+}
+function declaredType(node) {
+  if (ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node))
+    return node.type;
+  return;
+}
+function isClassLike(node) {
+  return ts.isClassDeclaration(node) || ts.isClassExpression(node) || ts.isInterfaceDeclaration(node);
+}
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 20);
+}
+async function addClassMetadata(repositoryPath, nodes, edges) {
+  const byFileAndName = new Map;
+  const classNodes = nodes.filter((node) => node.labels.some((label) => CLASS_LABELS.has(label)));
+  for (const node of classNodes) {
+    const key = `${node.filePath}\x00${node.name}`;
+    byFileAndName.set(key, [...byFileAndName.get(key) ?? [], node]);
+  }
+  const byName = new Map;
+  for (const node of classNodes)
+    byName.set(node.name, [...byName.get(node.name) ?? [], node]);
+  const sources = new Map;
+  const paths = new Set(classNodes.map((node) => node.filePath).filter(Boolean));
+  for (const filePath of paths) {
+    const scriptKind = SCRIPT_KINDS[extname(filePath).toLowerCase()];
+    if (scriptKind === undefined)
+      continue;
+    try {
+      const text = await readFile(resolve(repositoryPath, filePath), "utf8");
+      sources.set(filePath, ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, scriptKind));
+    } catch {}
+  }
+  const dependencies = new Map;
+  const existingDependencyPairs = new Set(edges.filter((edge) => edge.type === "DEPENDS_ON").map((edge) => `${edge.source}\x00${edge.target}`));
+  const addDependency = (source, target, reason, member) => {
+    if (source.id === target.id)
+      return;
+    const pair = `${source.id}\x00${target.id}`;
+    if (existingDependencyPairs.has(pair))
+      return;
+    const id = `derived:${hash(`${source.id}\x00${target.id}\x00${reason}\x00${member}`)}`;
+    dependencies.set(id, {
+      id,
+      source: source.id,
+      target: target.id,
+      type: "DEPENDS_ON",
+      properties: { derivedFrom: "typescript-ast", reason, member }
+    });
+  };
+  for (const [filePath, file] of sources) {
+    const visit = (node) => {
+      if (!isClassLike(node) || !node.name) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+      const name = node.name.text;
+      const candidates = byFileAndName.get(`${filePath}\x00${name}`) ?? [];
+      const start = sourceLine(file, node);
+      const owner = candidates.find((candidate) => candidate.startLine === start) ?? (candidates.length === 1 ? candidates[0] : undefined);
+      if (!owner) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+      const members = [];
+      const collect = (member) => {
+        const value = toMember(file, filePath, member);
+        const propertyType = declaredType(member);
+        if (value) {
+          members.push(value);
+          if (propertyType) {
+            for (const typeName of typeNames(propertyType)) {
+              const targets = byName.get(typeName) ?? [];
+              const target = targets.length === 1 ? targets[0] : targets.find((item) => item.filePath === filePath);
+              if (target)
+                addDependency(owner, target, "field-type", value.name);
+            }
+          }
+        }
+        if ((ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) && (member.type || member.parameters.length)) {
+          for (const parameter of member.parameters) {
+            if (!parameter.type)
+              continue;
+            for (const typeName of typeNames(parameter.type)) {
+              const targets = byName.get(typeName) ?? [];
+              const target = targets.length === 1 ? targets[0] : targets.find((item) => item.filePath === filePath);
+              if (target)
+                addDependency(owner, target, "method-parameter", member.name.getText(file));
+            }
+          }
+          if (member.type) {
+            for (const typeName of typeNames(member.type)) {
+              const targets = byName.get(typeName) ?? [];
+              const target = targets.length === 1 ? targets[0] : targets.find((item) => item.filePath === filePath);
+              if (target)
+                addDependency(owner, target, "method-return", member.name.getText(file));
+            }
+          }
+        }
+      };
+      for (const member of node.members)
+        collect(member);
+      if (members.length)
+        owner.members = members;
+      ts.forEachChild(node, visit);
+    };
+    visit(file);
+  }
+  const classesByQualifiedName = new Map(classNodes.map((node) => [node.qualifiedName, node]));
+  const methodOwners = new Map(nodes.filter((node) => node.labels.includes("Method") && typeof node.properties.parent_class === "string").map((node) => [node.id, classesByQualifiedName.get(node.properties.parent_class)]));
+  const nodesById = new Map(nodes.map((node) => [node.id, node]));
+  for (const edge of edges.filter((item) => item.type === "CALLS")) {
+    const source = methodOwners.get(edge.source);
+    const targetNode = nodesById.get(edge.target);
+    const target = targetNode && methodOwners.get(targetNode.id) || (targetNode?.labels.some((label) => CLASS_LABELS.has(label)) ? targetNode : undefined);
+    if (source && target)
+      addDependency(source, target, "method-call", targetNode?.name ?? "");
+  }
+  edges.push(...dependencies.values());
+}
+export {
+  addClassMetadata
+};

package/dist/index.js

@@ -4,6 +4,7 @@ import { basename, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { collectRows, runTool } from "./cbm.js";
 import { addCallables } from "./callables.js";
+import { addClassMetadata } from "./classes.js";
 var NODE_QUERY = `MATCH (n) RETURN id(n) AS id, labels(n) AS labels,
   n.name AS name, n.qualified_name AS qualifiedName, n.file_path AS filePath,
   n.start_line AS startLine, n.end_line AS endLine, properties(n) AS properties`;
@@ -118,6 +119,10 @@ async function exportGraph(repository, options = {}, run = runTool) {
   const selectedNodes = kind === "calls" ? nodes.filter((node) => endpoints.has(node.id) || node.labels.some((label) => label === "Function" || label === "Method")) : nodes;
   options.onProgress?.("Extracting callable signatures");
   addCallables(selectedNodes);
+  if (kind === "all") {
+    options.onProgress?.("Extracting class members and type dependencies");
+    addClassMetadata(repositoryPath, nodes, edges);
+  }
   return {
     schemaVersion: 1,
     generatedAt: new Date().toISOString(),

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@youichi/repograph",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Export repository code graphs with codebase-memory-mcp.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hi-youichi/repograph.git"
+  },
   "type": "module",
   "bin": {
     "repograph": "dist/cli.js"
@@ -12,7 +16,7 @@
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "test:integration": "REPOGRAPH_INTEGRATION=1 bun test test/integration.test.ts",
-    "build": "bun build ./src/cli.ts ./src/index.ts ./src/cbm.ts ./src/callables.ts --target node --outdir dist --external \"*\"",
+    "build": "bun build ./src/cli.ts ./src/index.ts ./src/cbm.ts ./src/callables.ts ./src/classes.ts --target node --outdir dist --external \"*\"",
     "prepack": "bun run build"
   },
   "dependencies": {
@@ -30,5 +34,8 @@
   },
   "files": [
     "dist"
-  ]
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
 }