deepseek-coordination 0.12.0 → 0.13.0

package/README.md

@@ -4,7 +4,7 @@
 
 A dual-face Cordis plugin for DeepSeek Harness: the host half owns a coordination SQLite database, seven model-facing tools and an HTTP surface; the web half mounts five composer dropdowns, a settings catalog and the service-level takeover dialog.
 
-**Status: v0.12.0 (2026-10-18).** This release adds a domain-concept layer split by ecosystem — tex, book, markdown, html, five programming languages, maven/npm and Office — plus a `kind` filter on the chain query, a directory layer, and the canonical `NodeRecord`. It builds on v0.11.0 (durable settings, DSH-owned reasoning, experimental cache proxy). The package version, changelog and release tarball are the same tree; claims below were checked against source, not against the design documents alone.
+**Status: v0.13.0 (2026-10-18).** This release makes `interface`, `type`, `enumeration` and `namespace` first-class declaration kinds across TypeScript, Java, Rust and PHP. It adds a domain-concept layer split by ecosystem — tex, book, markdown, html, five programming languages, maven/npm and Office — plus a `kind` filter on the chain query, a directory layer, and the canonical `NodeRecord`. It builds on v0.11.0 (durable settings, DSH-owned reasoning, experimental cache proxy). The package version, changelog and release tarball are the same tree; claims below were checked against source, not against the design documents alone.
 
 | Status | Meaning in this README |
 |---|---|
@@ -60,7 +60,7 @@ Install the packed tarball, not the GitHub source:
 
 ```powershell
 npm pack
-dsh plugin --profile <name> add .\deepseek-coordination-0.12.0.tgz
+dsh plugin --profile <name> add .\deepseek-coordination-0.13.0.tgz
 dsh --profile <name> --dump-config   # expect a deepseek-coordination layer
 ```
 
@@ -198,12 +198,12 @@ The file layer is not one parser with a bag of node kinds. Each system owns a mo
 | book | `book.ts` | `book`, `part`, `chapter`, `article`, `section`, `person`, `venue` — the only producer of `article` |
 | markdown | `markup.ts` | `document`, `chapter`, `heading`, `paragraph`, `div`, `link`, `code`, `section`, `sheet`, `cell`, `range`, `condition` |
 | html | `markup.ts` | `document`, `section` (`<article>` maps here), `chapter` (`<h1>`), `link`, `code` |
-| js/ts | `javascript.ts` | `class`, `function`, `method`, `variable`, `interface`, `type`, `enum`, `namespace`, `importation`, `exportation`, `condition` |
-| java | `java.ts` | `module`, `class`, `method`, `variable`, `importation` |
+| js/ts | `javascript.ts` | `class`, `function`, `method`, `variable`, `interface`, `type`, `enumeration`, `namespace`, `importation`, `exportation`, `condition` |
+| java | `java.ts` | `module`, `class`, `interface`, `enumeration`, `method`, `variable`, `importation` |
 | python | `python.ts` | `class`, `function`, `method`, `variable`, `importation` |
 | c/c++ | `c-family.ts` | `module`, `class`, `function`, `method`, `variable`, `importation` |
-| rust | `rust.ts` | `module`, `class`, `function`, `method`, `variable`, `importation` |
-| php | `php.ts` | `module`, `class`, `function`, `method`, `variable`, `importation` |
+| rust | `rust.ts` | `module`, `class`, `enumeration`, `function`, `method`, `variable`, `importation` |
+| php | `php.ts` | `module`, `class`, `interface`, `enumeration`, `function`, `method`, `variable`, `importation` |
 | maven | `maven.ts` | `project`, `module`, `dependency` (parent is a dependency with `label: 'parent'`) |
 | npm | `npm.ts` | `project`, `dependency`, `script` (the command body is never stored) |
 | office | `office.ts` | docx: `document`, `chapter`, `section`, `paragraph`, `link`; xlsx: `workbook`, `sheet`, `range`, `formula`; pptx: `document`, `slide`; pub/accdb: no nodes, one `unsupported-format` diagnostic |

package/README.zh-CN.md

@@ -4,7 +4,7 @@
 
 一个面向 DeepSeek Harness 的双端 Cordis 插件：宿主端持有协调 SQLite 数据库、7 个模型可见工具和一组 HTTP 路由；浏览器端在输入框挂载五个下拉框，并提供设置目录与服务级接管对话框。
 
-**当前版本：v0.12.0（2026-10-18）。** 本版新增按体系拆分的领域概念层——tex、book、markdown、html、五种编程语言、maven/npm 与 Office——并为 chain 查询加上 `kind` 过滤、加入目录层与规范 `NodeRecord`。它建立在 v0.11.0（持久设置、推理交还 DSH、实验性缓存代理）之上。包版本、更新日志和发布 tarball 来自同一棵树；下文按源码核对，不以设计文档代替实现。
+**当前版本：v0.13.0（2026-10-18）。** 本版让 `interface`、`type`、`enumeration`、`namespace` 成为 TypeScript、Java、Rust、PHP 的一等声明 kind，并新增按体系拆分的领域概念层——tex、book、markdown、html、五种编程语言、maven/npm 与 Office——并为 chain 查询加上 `kind` 过滤、加入目录层与规范 `NodeRecord`。它建立在 v0.11.0（持久设置、推理交还 DSH、实验性缓存代理）之上。包版本、更新日志和发布 tarball 来自同一棵树；下文按源码核对，不以设计文档代替实现。
 
 | 状态 | 含义 |
 |---|---|
@@ -198,12 +198,12 @@ deepseek-coordination/
 | book | `book.ts` | `book`、`part`、`chapter`、`article`、`section`、`person`、`venue`——`article` 的唯一产出者 |
 | markdown | `markup.ts` | `document`、`chapter`、`heading`、`paragraph`、`div`、`link`、`code`、`section`、`sheet`、`cell`、`range`、`condition` |
 | html | `markup.ts` | `document`、`section`（`<article>` 映射于此）、`chapter`（`<h1>`）、`link`、`code` |
-| js/ts | `javascript.ts` | `class`、`function`、`method`、`variable`、`interface`、`type`、`enum`、`namespace`、`importation`、`exportation`、`condition` |
-| java | `java.ts` | `module`、`class`、`method`、`variable`、`importation` |
+| js/ts | `javascript.ts` | `class`、`function`、`method`、`variable`、`interface`、`type`、`enumeration`、`namespace`、`importation`、`exportation`、`condition` |
+| java | `java.ts` | `module`、`class`、`interface`、`enumeration`、`method`、`variable`、`importation` |
 | python | `python.ts` | `class`、`function`、`method`、`variable`、`importation` |
 | c/c++ | `c-family.ts` | `module`、`class`、`function`、`method`、`variable`、`importation` |
-| rust | `rust.ts` | `module`、`class`、`function`、`method`、`variable`、`importation` |
-| php | `php.ts` | `module`、`class`、`function`、`method`、`variable`、`importation` |
+| rust | `rust.ts` | `module`、`class`、`enumeration`、`function`、`method`、`variable`、`importation` |
+| php | `php.ts` | `module`、`class`、`interface`、`enumeration`、`function`、`method`、`variable`、`importation` |
 | maven | `maven.ts` | `project`、`module`、`dependency`（parent 是 `label: 'parent'` 的 dependency） |
 | npm | `npm.ts` | `project`、`dependency`、`script`（命令体永不入库） |
 | office | `office.ts` | docx：`document`、`chapter`、`section`、`paragraph`、`link`；xlsx：`workbook`、`sheet`、`range`、`formula`；pptx：`document`、`slide`；pub/accdb：无节点，只出一条 `unsupported-format` 诊断 |

package/lib/index.mjs

@@ -23765,9 +23765,8 @@ function handleFunction(ctx, sig, position, symbols, exported, newline, scope, r
 	return endPosition + 1;
 }
 /**
-* TypeScript `interface`. `NodeKind` has no `interface` spelling, so the
-* closest existing kind (`class`, a named member-bearing type declaration) is
-* used and the binding is the type name (`identifier`).
+* TypeScript `interface`. The symbol kind is `interface`; the binding is the
+* type name (`identifier`).
 */
 function handleInterface(ctx, sig, position, symbols, exported, scope) {
 	const nameToken = sig[position + 1];
@@ -23781,15 +23780,14 @@ function handleInterface(ctx, sig, position, symbols, exported, scope) {
 	const endPosition = close < 0 ? open : close;
 	if (close < 0) ctx.unverifiable("unterminated interface body", sig[open].token.span);
 	const span = spanBetween(sig[declarationStartPosition(sig, position)].token, sig[endPosition].token);
-	symbols.push(newSymbol("class", nameToken.token.text, span, declarationStart(sig, position), sig[endPosition].index, exported.has(position), {
+	symbols.push(newSymbol("interface", nameToken.token.text, span, declarationStart(sig, position), sig[endPosition].index, exported.has(position), {
 		scope,
 		binding: "identifier"
 	}));
 	return endPosition + 1;
 }
 /**
-* TypeScript `type` alias. `NodeKind` has no `type` spelling; `definition` is
-* the closest existing kind for a named type/value definition.
+* TypeScript `type` alias. The symbol kind is `type`.
 */
 function handleTypeAlias(ctx, sig, position, symbols, exported, newline, scope) {
 	const nameToken = sig[position + 1];
@@ -23803,15 +23801,14 @@ function handleTypeAlias(ctx, sig, position, symbols, exported, newline, scope)
 	if (sig[cursor]?.token.text !== "=") return position + 1;
 	const endPosition = typeAliasEnd(sig, cursor + 1, newline);
 	const span = spanBetween(sig[declarationStartPosition(sig, position)].token, sig[endPosition].token);
-	symbols.push(newSymbol("definition", nameToken.token.text, span, declarationStart(sig, position), sig[endPosition].index, exported.has(position), {
+	symbols.push(newSymbol("type", nameToken.token.text, span, declarationStart(sig, position), sig[endPosition].index, exported.has(position), {
 		scope,
 		binding: "identifier"
 	}));
 	return endPosition + 1;
 }
 /**
-* TypeScript `enum` (including `const enum`). `NodeKind` has no `enum`
-* spelling; `definition` is the closest existing kind.
+* TypeScript `enum` (including `const enum`). The symbol kind is `enumeration`.
 */
 function handleEnum(ctx, sig, position, symbols, exported, scope) {
 	const nameToken = sig[position + 1];
@@ -23824,15 +23821,14 @@ function handleEnum(ctx, sig, position, symbols, exported, scope) {
 	const exportedEnum = exported.has(position) || sig[position - 1]?.token.text === "const" && exported.has(position - 1);
 	const startPosition = sig[position - 1]?.token.text === "const" ? declarationStartPosition(sig, position - 1) : declarationStartPosition(sig, position);
 	const span = spanBetween(sig[startPosition].token, sig[endPosition].token);
-	symbols.push(newSymbol("definition", nameToken.token.text, span, sig[startPosition].index, sig[endPosition].index, exportedEnum, {
+	symbols.push(newSymbol("enumeration", nameToken.token.text, span, sig[startPosition].index, sig[endPosition].index, exportedEnum, {
 		scope,
 		binding: "identifier"
 	}));
 	return endPosition + 1;
 }
 /**
-* TypeScript `namespace` / `module` block. `module` is the existing `NodeKind`
-* spelling for a declaration container, so both map to it.
+* TypeScript `namespace` / `module` block. Both map to the `namespace` kind.
 */
 function handleNamespace$1(ctx, sig, position, symbols, exported, scope) {
 	const nameToken = sig[position + 1];
@@ -23856,7 +23852,7 @@ function handleNamespace$1(ctx, sig, position, symbols, exported, scope) {
 	const endPosition = close < 0 ? open : close;
 	if (close < 0) ctx.unverifiable("unterminated namespace body", sig[open].token.span);
 	const span = spanBetween(sig[declarationStartPosition(sig, position)].token, sig[endPosition].token);
-	symbols.push(newSymbol("module", name, span, declarationStart(sig, position), sig[endPosition].index, exported.has(position), {
+	symbols.push(newSymbol("namespace", name, span, declarationStart(sig, position), sig[endPosition].index, exported.has(position), {
 		scope,
 		binding: "identifier"
 	}));
@@ -26742,7 +26738,8 @@ function buildAst(ctx, declarations) {
 *    `importation` node each, so the dependency layer can build `depends`
 *    edges from the same reference shape the JavaScript parser emits;
 *  - `class`, `interface`, `enum`, `record` and `@interface` declarations
-*    (including nested types) -> one `class` node each;
+*    (including nested types) -> one node each, using the precise declaration
+*    kind (`class`, `interface` or `enumeration`);
 *  - methods and constructors (including abstract/interface methods and
 *    compact record constructors) -> one `method` node each, with a
 *    declaration-signature span (modifiers/annotations through the body `{` or
@@ -26755,9 +26752,11 @@ function buildAst(ctx, declarations) {
 * |-----------------------------------|---------------------|------|
 * | `package`                         | `module`            | existing kind |
 * | `import` / `import static`        | `importation`       | existing kind |
-* | `class`                           | `class`             | exact |
-* | `interface` / `enum` / `record`   | `class`             | no dedicated NodeKind exists; `class` is the closest declaration kind |
-* | `@interface`                      | `class`             | same mapping as `interface` |
+* | `class`                           | `class`             | exact, no label |
+* | `interface`                       | `interface`         | exact, no label |
+* | `enum`                            | `enumeration`       | exact, no label |
+* | `record`                          | `class`             | `label: 'record'` (a record is a final class) |
+* | `@interface`                      | `interface`         | `label: 'annotation'` |
 * | method / constructor              | `method`            | exact |
 * | field / constant                  | `variable`          | existing kind; `label: 'constant'` only for an explicit `static final` |
 *
@@ -27379,6 +27378,28 @@ function typeDeclarationAt(tokens, position) {
 		};
 	}
 }
+/**
+* Map a Java type form onto its precise `NodeMetadata.kind`.
+*
+* `record` stays `class` (Java records are final classes) and `@interface`
+* stays `interface` (an annotation type is an interface); the distinction is
+* preserved in `label` rather than folding every declaration into `class`.
+*/
+function javaTypeNode(form) {
+	switch (form) {
+		case "class": return { kind: "class" };
+		case "interface": return { kind: "interface" };
+		case "enum": return { kind: "enumeration" };
+		case "record": return {
+			kind: "class",
+			label: "record"
+		};
+		case "@interface": return {
+			kind: "interface",
+			label: "annotation"
+		};
+	}
+}
 /** Scan one type declaration and its members; returns the position after it. */
 function scanType(state, declaration, startPosition, depth) {
 	const { ctx, tokens } = state;
@@ -27396,17 +27417,20 @@ function scanType(state, declaration, startPosition, depth) {
 	const open = findTypeBodyOpen(tokens, declaration.name + 1, tokens.length);
 	const close = open < 0 ? -1 : braceClose(state, open);
 	const startToken = tokens[startPosition] ?? nameToken;
+	const span = {
+		start: startToken.span.start,
+		end: open >= 0 ? tokens[open].span.start : nameToken.span.end,
+		line: startToken.span.line,
+		column: startToken.span.column
+	};
+	const typeNode = javaTypeNode(declaration.form);
 	emitNode$1(state, {
-		kind: "class",
+		kind: typeNode.kind,
 		name,
-		span: {
-			start: startToken.span.start,
-			end: open >= 0 ? tokens[open].span.start : nameToken.span.end,
-			line: startToken.span.line,
-			column: startToken.span.column
-		},
-		locatorKind: "class",
-		target: `${PARSER_ID$3}:class:${name}`
+		span,
+		locatorKind: typeNode.kind,
+		target: `${PARSER_ID$3}:${typeNode.kind}:${name}`,
+		...typeNode.label === void 0 ? {} : { label: typeNode.label }
 	});
 	if (open < 0) {
 		ctx.unverifiable(`type declaration "${name}" has no body`, startToken.span);
@@ -27914,9 +27938,10 @@ function signatureSpan(tokens, startPosition, endPosition) {
 *    goes through the shared lexical classifier);
 *  - `mod name;` and `mod name { ... }` → one `module` node (`label: 'mod'`);
 *    the body of an inline module is scanned for module-level items;
-*  - `struct`/`enum`/`trait` declarations → one `class` node whose `label` is
-*    the Rust keyword; the declared type name is the `name`. Bodies are
-*    skipped (fields, variants and trait signatures are not projected);
+*  - `struct`/`trait` declarations → one `class` node whose `label` is the
+*    Rust keyword; `enum` declarations → one `enumeration` node (`label:
+*    'enum'`). The declared type name is the `name`. Bodies are skipped
+*    (fields, variants and trait signatures are not projected);
 *  - `impl Type { ... }` → one `class` node with `label: 'implementation'` and
 *    `name` = the implemented type (`Type` in `impl Trait for Type`); the body
 *    is scanned for direct members only;
@@ -27929,11 +27954,11 @@ function signatureSpan(tokens, startPosition, endPosition) {
 *    nodes; attributes (`#[...]`, `#![...]`) and doc comments are skipped
 *    without breaking the scan; `type` aliases are skipped.
 *
-* The taxonomy is strict: only existing `NodeKind` spellings are emitted
-* (`class`, `module`, `function`, `method`, `variable`, `importation`). Rust
-* nuance lives in `label`, never in a new kind. Bodies are never returned: a
-* node carries only a body-free span, fragment coordinates and (when a path is
-* known) a `NodeReference`.
+* The taxonomy uses the precise `NodeKind` spellings (`class`, `enumeration`,
+* `module`, `function`, `method`, `variable`, `importation`). Rust nuance that
+* has no dedicated kind lives in `label`, never in a new kind. Bodies are never
+* returned: a node carries only a body-free span, fragment coordinates and
+* (when a path is known) a `NodeReference`.
 *
 * Conservative gaps, documented rather than guessed:
 *
@@ -28306,7 +28331,22 @@ function handleRustMod(ctx, tokens, position, sink) {
 	ctx.parseError("mod declaration has neither a body nor a semicolon", tokenSpan$1(keyword));
 	return position + 2;
 }
-/** `struct`/`enum`/`trait` declarations; the body is skipped. */
+/**
+* Map a class-like Rust item keyword onto its precise node kind.
+*
+* `struct` and `trait` stay `class` with the keyword as label; `enum` has a
+* dedicated `enumeration` kind and keeps `label: 'enum'`.
+*/
+function rustClassLikeNode(keyword) {
+	return keyword === "enum" ? {
+		kind: "enumeration",
+		label: "enum"
+	} : {
+		kind: "class",
+		label: keyword
+	};
+}
+/** `struct`/`trait` (a `class`) and `enum` (an `enumeration`); bodies are skipped. */
 function handleRustClassLike(ctx, tokens, position, sink) {
 	const keyword = tokens[position];
 	const kind = keyword.text;
@@ -28349,10 +28389,11 @@ function handleRustClassLike(ctx, tokens, position, sink) {
 		endPosition = Math.min(tokens.length - 1, position + 1);
 		next = Math.min(tokens.length, position + 2);
 	}
+	const node = rustClassLikeNode(kind);
 	if (!sink.addSymbol({
-		kind: "class",
+		kind: node.kind,
 		name: nameToken.text,
-		label: kind,
+		label: node.label,
 		span: tokenRangeSpan$1(keyword, tokens[endPosition])
 	})) return tokens.length;
 	return next;
@@ -29077,8 +29118,9 @@ function buildRustAst(ctx, declarations) {
 *    path (optionally parenthesized) → one `import` reference and one
 *    `importation` node whose `label` is the keyword. Non-literal include
 *    targets produce no reference and one `unverifiable` diagnostic;
-*  - `class`, `interface`, `trait` and `enum` → one `class` node whose
-*    `label` is the keyword; the body is scanned for methods. Anonymous
+*  - `class`, `interface`, `trait` and `enum` → one node each, using the
+*    precise declaration kind (`class`, `interface` or `enumeration`) with the
+*    PHP keyword as `label`; the body is scanned for methods. Anonymous
 *    classes (`new class { ... }`) are skipped without a node;
 *  - `function name(` at top level → `function`; a direct member of a
 *    class-like body → `method`. Bodies are skipped, so closures and nested
@@ -29087,11 +29129,11 @@ function buildRustAst(ctx, declarations) {
 *    keeps the leading `$` exactly as written. Assignments inside class,
 *    function, closure and control-flow bodies are not projected.
 *
-* The taxonomy is strict: only existing `NodeKind` spellings are emitted
-* (`module`, `class`, `function`, `method`, `variable`, `importation`). PHP
-* nuance lives in `label`, never in a new kind. Bodies are never returned: a
-* node carries only a body-free span, fragment coordinates and (when a path is
-* known) a `NodeReference`.
+* The taxonomy uses the precise `NodeKind` spellings (`module`, `class`,
+* `interface`, `enumeration`, `function`, `method`, `variable`,
+* `importation`). PHP nuance that has no dedicated kind lives in `label`, never
+* in a new kind. Bodies are never returned: a node carries only a body-free
+* span, fragment coordinates and (when a path is known) a `NodeReference`.
 *
 * Conservative gaps, documented rather than guessed:
 *
@@ -29465,7 +29507,27 @@ function handlePhpInclude(ctx, tokens, position, sink) {
 	if (!sink.addReference(reference, keyword.text)) return tokens.length;
 	return skipPhpToSemicolon(tokens, cursor + 1);
 }
-/** `class`/`interface`/`trait`/`enum`; the body is scanned for methods. */
+/**
+* Map a PHP class-like keyword onto its precise node kind.
+*
+* `class` and `trait` stay `class` with the keyword as label; `interface` and
+* `enum` use their dedicated kinds.
+*/
+function phpClassLikeNode(keyword) {
+	if (keyword === "interface") return {
+		kind: "interface",
+		label: keyword
+	};
+	if (keyword === "enum") return {
+		kind: "enumeration",
+		label: keyword
+	};
+	return {
+		kind: "class",
+		label: keyword
+	};
+}
+/** `class`/`trait` (`class`), `interface`, `enum`; the body is scanned for methods. */
 function handlePhpClassLike(ctx, tokens, position, sink) {
 	const keyword = tokens[position];
 	const kind = keyword.text;
@@ -29500,20 +29562,21 @@ function handlePhpClassLike(ctx, tokens, position, sink) {
 		return Math.min(tokens.length, position + 2);
 	}
 	const close = findMatching$1(tokens, open, "{", "}");
+	const node = phpClassLikeNode(kind);
 	if (close < 0) {
 		ctx.parseError(`${kind} body is unterminated`, tokenSpan(tokens[open]));
 		if (!sink.addSymbol({
-			kind: "class",
+			kind: node.kind,
 			name: next.text,
-			label: kind,
+			label: node.label,
 			span: tokenRangeSpan(keyword, tokens[open])
 		})) return tokens.length;
 		return tokens.length;
 	}
 	if (!sink.addSymbol({
-		kind: "class",
+		kind: node.kind,
 		name: next.text,
-		label: kind,
+		label: node.label,
 		span: tokenRangeSpan(keyword, tokens[close])
 	})) return tokens.length;
 	scanPhpClassBody(ctx, tokens, open, close, next.text, sink);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepseek-coordination",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "A dual-face Cordis plugin for DeepSeek Harness: the host half owns a coordination SQLite database, seven model-facing tools and an HTTP surface; the web half mounts five composer dropdowns, a settings catalog and the service-level takeover dialog.",
   "keywords": [
     "deepseek-harness",