@youichi/repograph 0.1.0 → 0.1.2

package/README.md

@@ -1,5 +1,7 @@
 # repograph
 
+[English](README.md) | [简体中文](README.zh-CN.md)
+
 Export repository indexes as JSON graphs for other programs using the [codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp) CLI. No language model, API key, or MCP client is required.
 
 ## Installation
@@ -17,13 +19,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 +37,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 +88,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, class-like nodes include a normalized `members` array whenever the upstream indexer emits `Field` or `Property` nodes. Each member also remains a graph node and receives a `HAS_PROPERTY` edge from its owning class. Entries include declared type text when available, source lines, visibility, static, optional, and readonly flags. The exporter derives `DEPENDS_ON` edges from upstream field and method type metadata when the target class resolves unambiguously. TypeScript and JavaScript receive an AST fallback for declared fields, accessors, and type references when upstream field nodes are absent. Derived edges identify their source in `properties.derivedFrom` (`upstream-index` or `typescript-ast`) and include a `reason`. `calls` exports intentionally omit class members and these dependencies. Available fields and relationships still depend on what the upstream indexer extracts for each language.
+
+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 a `HAS_PROPERTY` edge from `Customer` to its `address` field node and an edge such as `{ "source": "<Customer id>", "target": "<Address id>", "type": "DEPENDS_ON", "properties": { "derivedFrom": "upstream-index", "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
@@ -136,15 +165,23 @@ for (const node of graph.nodes) {
 bun run typecheck
 bun test
 bun run test:integration
+bun run test:languages
 ```
 
-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.
+Unit tests cover pagination, cursors, truncation handling, file line counts, structured callable metadata, and completion of asynchronous class enrichment. Integration tests use the real native backend for the original multi-file TypeScript project and a corpus covering all 162 vendored grammars in the pinned backend. The language suite exercises the CLI's JSON output and the API's `calls` projection, definition preservation, file line counts, graph integrity, parse diagnostics, isolated functions, and class metadata. All 66 caller/callee samples require a resolved `CALLS` edge in both export modes. Temporary repositories and indexes are removed after each suite.
+
+See [the language corpus](test/fixtures/languages/README.md) for coverage boundaries, fixture provenance, and the optional JSON coverage report. The presence of a vendored grammar does not guarantee that the upstream CLI can discover it as a standalone source file.
+
+## 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.
+- The exporter normalizes upstream class fields and type metadata without language-specific adapters. The pinned indexer does not emit every field or type relationship for every language, so missing upstream information cannot be reconstructed generically. 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/README.zh-CN.md

@@ -0,0 +1,189 @@
+# repograph
+
+[English](README.md) | [简体中文](README.zh-CN.md)
+
+使用 [codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp) CLI 将代码仓库索引导出为 JSON 图数据，供其他程序使用。无需语言模型、API 密钥或 MCP 客户端。
+
+## 安装
+
+需要 Node.js 22 或更高版本。通过 `npx` 直接运行：
+
+```bash
+npx @youichi/repograph export /path/to/repository
+```
+
+本项目固定使用 `codebase-memory-mcp@0.12.1`。首次安装会下载适用于当前平台的原生二进制文件，需要访问 npm 和 GitHub。后续索引操作均在本地运行。无需全局安装，也无需通过 `codebase-memory-mcp install` 配置编辑器或智能体。
+
+## 导出图数据
+
+可在任意目录运行以下命令：
+
+```bash
+# 导出索引中的全部节点和关系，以及从源码提取的类成员和依赖
+npx @youichi/repograph export ../anureo-sdk
+
+# 指定输出文件
+npx @youichi/repograph export /path/to/repository --out .repograph/repository.json
+
+# 仅导出 CALLS 边、函数和方法，以及这些边的端点
+npx @youichi/repograph export ../anureo-sdk --kind calls --out .repograph/calls.json
+
+# 查看可用选项
+npx @youichi/repograph --help
+```
+
+默认输出路径为当前工作目录下的 `.repograph/graph.json`。进度信息写入 stderr；成功后，stdout 会显示输出路径以及节点和边的数量。失败时以退出码 1 结束，部分结果不会覆盖已有的输出文件。
+
+| 选项 | 默认值 | 用途 |
+| --- | --- | --- |
+| `--out`, `-o` | `.repograph/graph.json` | JSON 输出路径 |
+| `--kind` | `all` | `all` 包含类结构和依赖；`calls` 仅保留直接调用关系 |
+| `--project` | 目录名 + 绝对路径的哈希值 | 自定义上游索引名称 |
+| `--page-size` | `500` | 每批查询的行数，范围为 1 至 10000 |
+
+每次导出都会先刷新索引，再分别读取节点和边。查询支持分页和响应游标。如果检测到求值限制、截断后缺少后续游标、重复 ID、缺失端点或数量不匹配，导出会停止。调用图会保留没有调用边的函数和方法。
+
+## 输出结构
+
+以下为简化示例。实际属性取决于编程语言和上游分析结果：
+
+```json
+{
+  "schemaVersion": 1,
+  "generatedAt": "2026-11-12T00:00:00.000Z",
+  "repositoryPath": "/path/to/repository",
+  "project": "repository-0123456789ab",
+  "kind": "calls",
+  "indexReport": { "status": "indexed", "nodes": 2, "edges": 1 },
+  "files": {
+    "main.ts": { "lines": 7 }
+  },
+  "nodes": [
+    {
+      "id": "1",
+      "labels": ["Function"],
+      "name": "checkout",
+      "qualifiedName": "repository.main.checkout",
+      "filePath": "main.ts",
+      "startLine": 1,
+      "endLine": 3,
+      "properties": {},
+      "callable": { "parameters": [], "returnType": null }
+    },
+    {
+      "id": "2",
+      "labels": ["Function"],
+      "name": "validate",
+      "qualifiedName": "repository.main.validate",
+      "filePath": "main.ts",
+      "startLine": 5,
+      "endLine": 7,
+      "properties": {},
+      "callable": { "parameters": [], "returnType": null }
+    }
+  ],
+  "edges": [
+    { "id": "1", "source": "1", "target": "2", "type": "CALLS", "properties": {} }
+  ]
+}
+```
+
+节点 ID 和边 ID 均为字符串，分属独立的命名空间。边的 `source` 和 `target` 指向节点 ID。这些 ID 用于关联当前导出中的记录，不保证在多次索引之间保持稳定。`indexReport` 保留上游索引报告；其中的数量描述的是上游索引，在过滤或添加从源码提取的类数据后，可能与导出的图数据不同。
+
+在 `all` 和 `calls` 两种导出模式中，TypeScript 和 JavaScript 的 `Function`、`Method` 节点均包含 `callable` 元数据。导出器使用 TypeScript 解析器解析上游的 `properties.signature` 和 `properties.return_type`，不会加载目标项目的依赖或推断类型。支持的文件扩展名为 `.ts`、`.tsx`、`.mts`、`.cts`、`.js`、`.jsx`、`.mjs` 和 `.cjs`。其他语言和节点标签不包含 `callable`。原始 `properties` 保持不变，新增此字段后仍使用 `schemaVersion: 1`。
+
+在 `all` 模式下，只要上游索引器生成了 `Field` 或 `Property` 节点，类及类似结构的节点就会包含规范化的 `members` 数组。每个成员同时保留为图节点，并通过一条从所属类指向该成员的 `HAS_PROPERTY` 边关联。成员条目包含可用的声明类型文本、源码行号、可见性，以及静态、可选和只读标记。当目标类可被唯一确定时，导出器会根据上游字段和方法的类型元数据派生 `DEPENDS_ON` 边。如果缺少上游字段节点，TypeScript 和 JavaScript 会通过 AST 补充解析声明的字段、访问器和类型引用。派生边通过 `properties.derivedFrom` 标明来源（`upstream-index` 或 `typescript-ast`），并包含 `reason`。`calls` 模式不包含类成员及这些依赖。可用字段和关系仍取决于上游索引器对各语言的提取能力。
+
+例如，若 `Customer` 包含 `address?: Address` 字段和 `save(input: Address): Result` 方法，导出结果会包含：
+
+```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
+    }
+  ]
+}
+```
+
+图中还会包含一条从 `Customer` 指向其 `address` 字段节点的 `HAS_PROPERTY` 边，以及类似 `{ "source": "<Customer id>", "target": "<Address id>", "type": "DEPENDS_ON", "properties": { "derivedFrom": "upstream-index", "reason": "field-type", "member": "address" } }` 的边。上游已有的 `INHERITS` 和 `IMPLEMENTS` 边会原样保留。
+
+例如，`function load(id: string, count = 1, ...tags: string[]): Promise<string[]>` 会生成：
+
+```json
+{
+  "callable": {
+    "parameters": [
+      { "name": "id", "type": "string", "optional": false, "rest": false },
+      { "name": "count", "type": null, "optional": true, "rest": false },
+      { "name": "tags", "type": "string[]", "optional": false, "rest": true }
+    ],
+    "returnType": "Promise<string[]>"
+  }
+}
+```
+
+参数顺序与签名一致。`name` 保留源码中的绑定名称或解构模式。`type` 为声明的类型文本，没有类型注解时为 `null`。带有 `?` 标记或默认初始值的参数，其 `optional` 为 true；`rest` 用于标识 `...` 参数。默认值不会触发类型推断。如果上游签名包含 TypeScript 源码中的 `this` 参数，该参数也会保留。
+
+`parameters: []` 表示已知参数列表为空；`parameters: null` 表示上游签名缺失或无法解析。`returnType` 不包含开头的冒号，没有类型注解时为 `null`；显式声明的 `void`、`never` 和 `Promise<T>` 会保留。如果签名与返回类型注解组合后格式无效，两个字段均为 `null`。缺失的类型不会被替换为 `any` 或 `void`。导出器仅导出每个上游节点保留的签名，不会重建独立的重载、成对的访问器、泛型参数声明或上游遗漏的符号。
+
+`files` 以各个 `File` 节点的 `filePath` 为键，通过 `lines` 记录文件的实际行数，包括空行和注释。空文件为 `0` 行，文件末尾的换行符不会额外增加一行。支持 LF、CRLF 和 CR 换行符。无法读取的文件，其行数为 `null`。行数在导出时直接从源码文件读取，不根据上游节点的 `properties.lines` 推断。`all` 和 `calls` 模式都会保留完整索引中的文件信息，即使调用图已过滤掉文件节点。不会扫描索引之外的文件。
+
+## 在 TypeScript 中使用
+
+本项目也导出了一个轻量封装，内部调用 CLI：
+
+```typescript
+import { exportGraph } from "./src/index.ts";
+
+const graph = await exportGraph("../anureo-sdk", {
+  kind: "calls",
+  onProgress: console.error,
+});
+
+console.log(graph.nodes, graph.edges);
+
+for (const node of graph.nodes) {
+  if (node.callable) console.log(node.name, node.callable.parameters, node.callable.returnType);
+}
+```
+
+## 开发与验证
+
+```bash
+bun run typecheck
+bun test
+bun run test:integration
+bun run test:languages
+```
+
+单元测试覆盖分页、游标、截断处理、文件行数、结构化的可调用对象元数据，以及异步类成员提取完成后才返回的行为。集成测试使用真实原生后端，覆盖原有多文件 TypeScript 项目和固定依赖中的全部 162 种语法样例，校验 CLI JSON 输出、API 的 `calls` 图、定义保留、文件行数、图完整性、解析诊断、孤立函数和类元数据。66 组调用样例均要求在两种导出模式中生成 `CALLS` 边。测试结束后清理临时仓库和索引。
+
+覆盖边界、样例来源和可选 JSON 报告见[全语言测试说明](test/fixtures/languages/README.md)。内置语法不一定能通过上游 CLI 作为独立源码文件被识别。
+
+## 发布
+
+推送版本标签后，GitHub Actions 会发布新版本。首次发布前，请为 npm 包 `@youichi/repograph` 配置 Trusted Publishing，使用 GitHub 用户 `hi-youichi`、仓库 `repograph` 和工作流文件 `publish-npm.yml`，并允许该发布方直接执行 `npm publish`。随后将 `package.json` 更新为新版本，再推送对应标签，例如 `v0.1.1`。工作流会检查标签是否与包版本匹配、安装依赖、运行类型检查和单元测试，然后构建并发布，同时附带 npm provenance 来源证明。GitHub Secrets 中不存储 npm 令牌。
+
+## 限制
+
+- 导出结果包含上游实际索引到的静态关系，不保证覆盖所有运行时调用。对反射、动态分派和框架约定的支持因语言而异。
+- 上游索引器会跳过 `node_modules`、匹配忽略规则的文件及其他被排除的输入。可通过 `indexReport` 中的跳过和解析数量评估覆盖范围。
+- `calls` 模式仅保留 `CALLS` 边，不会将 `CALL_REFERENCE` 或 `USAGE` 视为直接调用。上游分析器也可能在属性中记录递归信息，而不生成自调用边。
+- 导出器无需针对各语言编写适配器，即可规范化上游类字段和类型元数据。固定版本的索引器并不会为每种语言生成全部字段或类型关系，因此无法用通用方式重建上游缺失的信息。不会根据没有类型注解的初始值推断类型引用。
+- 导出期间请保持源码文件和项目索引不变，并防止其他进程同时重建索引。导出结果不是跨查询的事务性快照。
+- 结果会先在内存中组装，再写入磁盘。大型仓库需要足够内存；触及上游求值限制时会报错。
+- 请将输出放在目标仓库之外，以免后续索引将导出文件视为输入。上游索引会保留在本地缓存中。
+
+本项目目前仅导出 JSON，可使用 Graphviz、Cytoscape 或其他前端工具进行可视化。

package/dist/classes.js

@@ -0,0 +1,285 @@
+// 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 referencedNames(typeText) {
+  return new Set(typeText.match(/[\p{L}_$][\p{L}\p{N}_$]*/gu) ?? []);
+}
+function propertyText(node, ...keys) {
+  for (const key of keys) {
+    const value = node.properties[key];
+    if (typeof value === "string" && value.trim())
+      return value.replace(/^\s*:\s*/, "").trim();
+  }
+  return;
+}
+function propertyTypes(value) {
+  if (typeof value === "string")
+    return [value];
+  if (Array.isArray(value))
+    return value.filter((item) => typeof item === "string");
+  return [];
+}
+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 byQualifiedName = new Map;
+  for (const node of classNodes) {
+    byQualifiedName.set(node.qualifiedName, [...byQualifiedName.get(node.qualifiedName) ?? [], node]);
+  }
+  const resolveClass = (name, filePath) => {
+    const candidates = byName.get(name) ?? [];
+    return candidates.find((item) => item.filePath === filePath) ?? (candidates.length === 1 ? candidates[0] : undefined);
+  };
+  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 propertyEdges = 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, derivedFrom) => {
+    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, reason, member }
+    });
+  };
+  for (const field of nodes.filter((node) => node.labels.includes("Field") || node.labels.includes("Property"))) {
+    const parent = field.properties.parent_class;
+    if (typeof parent !== "string")
+      continue;
+    const candidates = byQualifiedName.get(parent) ?? [];
+    const owner = candidates.find((item) => item.filePath === field.filePath) ?? (candidates.length === 1 ? candidates[0] : undefined);
+    if (!owner)
+      continue;
+    const visibilityText = propertyText(field, "visibility", "access")?.toLowerCase();
+    const member = {
+      name: field.name,
+      kind: "field",
+      type: propertyText(field, "return_type", "type", "field_type") ?? null,
+      filePath: field.filePath,
+      startLine: field.startLine ?? owner.startLine ?? 1,
+      endLine: field.endLine ?? field.startLine ?? owner.endLine ?? 1,
+      visibility: visibilityText === "private" || visibilityText === "protected" ? visibilityText : "public",
+      static: field.properties.static === true || field.properties.is_static === true,
+      optional: field.properties.optional === true || field.properties.is_optional === true,
+      readonly: field.properties.readonly === true || field.properties.is_readonly === true
+    };
+    owner.members = [...owner.members ?? [], member];
+    const edgeId = `derived:${hash(`${owner.id}\x00${field.id}\x00HAS_PROPERTY`)}`;
+    propertyEdges.set(edgeId, {
+      id: edgeId,
+      source: owner.id,
+      target: field.id,
+      type: "HAS_PROPERTY",
+      properties: { derivedFrom: "upstream-index" }
+    });
+    if (member.type) {
+      for (const typeName of referencedNames(member.type)) {
+        const target = resolveClass(typeName, field.filePath);
+        if (target)
+          addDependency(owner, target, "field-type", field.name, "upstream-index");
+      }
+    }
+  }
+  for (const method of nodes.filter((node) => node.labels.includes("Method"))) {
+    const parent = method.properties.parent_class;
+    if (typeof parent !== "string")
+      continue;
+    const candidates = byQualifiedName.get(parent) ?? [];
+    const owner = candidates.find((item) => item.filePath === method.filePath) ?? (candidates.length === 1 ? candidates[0] : undefined);
+    if (!owner)
+      continue;
+    const parameterTypes = propertyTypes(method.properties.param_types);
+    for (const typeText of parameterTypes) {
+      for (const typeName of referencedNames(typeText)) {
+        const target = resolveClass(typeName, method.filePath);
+        if (target)
+          addDependency(owner, target, "method-parameter", method.name, "upstream-index");
+      }
+    }
+    const returnType = propertyText(method, "return_type", "returnType");
+    if (returnType) {
+      for (const typeName of referencedNames(returnType)) {
+        const target = resolveClass(typeName, method.filePath);
+        if (target)
+          addDependency(owner, target, "method-return", method.name, "upstream-index");
+      }
+    }
+  }
+  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 target = resolveClass(typeName, filePath);
+              if (target)
+                addDependency(owner, target, "field-type", value.name, "typescript-ast");
+            }
+          }
+        }
+        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 target = resolveClass(typeName, filePath);
+              if (target)
+                addDependency(owner, target, "method-parameter", member.name.getText(file), "typescript-ast");
+            }
+          }
+          if (member.type) {
+            for (const typeName of typeNames(member.type)) {
+              const target = resolveClass(typeName, filePath);
+              if (target)
+                addDependency(owner, target, "method-return", member.name.getText(file), "typescript-ast");
+            }
+          }
+        }
+      };
+      for (const member of node.members)
+        collect(member);
+      for (const member of members) {
+        const isAlreadyIndexed = (owner.members ?? []).some((existing) => existing.name === member.name && existing.filePath === member.filePath && existing.startLine === member.startLine && existing.kind === member.kind);
+        if (!isAlreadyIndexed)
+          owner.members = [...owner.members ?? [], member];
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(file);
+  }
+  const classForQualifiedName = (qualifiedName, filePath) => {
+    const candidates = byQualifiedName.get(qualifiedName) ?? [];
+    return candidates.find((item) => item.filePath === filePath) ?? (candidates.length === 1 ? candidates[0] : undefined);
+  };
+  const methodOwners = new Map(nodes.filter((node) => node.labels.includes("Method") && typeof node.properties.parent_class === "string").map((node) => [node.id, classForQualifiedName(node.properties.parent_class, node.filePath)]));
+  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 ?? "", "codebase-memory-mcp");
+  }
+  edges.push(...propertyEdges.values(), ...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");
+    await 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.2",
   "description": "Export repository code graphs with codebase-memory-mcp.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hi-youichi/repograph.git"
+  },
   "type": "module",
   "bin": {
     "repograph": "dist/cli.js"
@@ -11,8 +15,9 @@
     "start": "bun run src/cli.ts",
     "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 \"*\"",
+    "test:integration": "REPOGRAPH_INTEGRATION=1 bun test test/integration.test.ts test/languages.integration.test.ts",
+    "test:languages": "REPOGRAPH_INTEGRATION=1 bun test test/languages.integration.test.ts",
+    "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 +35,8 @@
   },
   "files": [
     "dist"
-  ]
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
 }