@ctxo/lang-go 0.7.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alper Hankendi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { ILanguageAdapter, SymbolKind, SymbolNode, GraphEdge, ComplexityMetrics, CtxoLanguagePlugin } from '@ctxo/plugin-api';
+import Parser, { Tree, SyntaxNode } from 'tree-sitter';
+
+type Language = Parameters<InstanceType<typeof Parser>['setLanguage']>[0];
+
+declare abstract class TreeSitterAdapter implements ILanguageAdapter {
+    abstract readonly extensions: readonly string[];
+    readonly tier: "syntax";
+    protected parser: Parser;
+    protected symbolRegistry: Map<string, "function" | "class" | "interface" | "method" | "variable" | "type">;
+    constructor(language: Language);
+    isSupported(filePath: string): boolean;
+    setSymbolRegistry(registry: Map<string, SymbolKind>): void;
+    protected parse(source: string): Tree;
+    protected buildSymbolId(filePath: string, name: string, kind: SymbolKind): string;
+    protected nodeToLineRange(node: SyntaxNode): {
+        startLine: number;
+        endLine: number;
+        startOffset: number;
+        endOffset: number;
+    };
+    protected countCyclomaticComplexity(node: SyntaxNode, branchTypes: string[]): number;
+    abstract extractSymbols(filePath: string, source: string): Promise<SymbolNode[]>;
+    abstract extractEdges(filePath: string, source: string): Promise<GraphEdge[]>;
+    abstract extractComplexity(filePath: string, source: string): Promise<ComplexityMetrics[]>;
+}
+
+declare class GoAdapter extends TreeSitterAdapter {
+    readonly extensions: readonly [".go"];
+    constructor();
+    extractSymbols(filePath: string, source: string): Promise<SymbolNode[]>;
+    extractEdges(filePath: string, source: string): Promise<GraphEdge[]>;
+    extractComplexity(filePath: string, source: string): Promise<ComplexityMetrics[]>;
+    private isExported;
+    private extractReceiverType;
+    private extractTypeSymbols;
+    private extractImportEdges;
+    private findFirstExportedSymbolId;
+}
+
+declare const plugin: CtxoLanguagePlugin;
+
+export { GoAdapter, TreeSitterAdapter, plugin as default, plugin };

package/dist/index.js

@@ -0,0 +1,258 @@
+// src/go-adapter.ts
+import GoLanguage from "tree-sitter-go";
+
+// src/tree-sitter-adapter.ts
+import Parser from "tree-sitter";
+import { extname } from "path";
+var TreeSitterAdapter = class {
+  tier = "syntax";
+  parser;
+  symbolRegistry = /* @__PURE__ */ new Map();
+  constructor(language) {
+    this.parser = new Parser();
+    this.parser.setLanguage(language);
+  }
+  isSupported(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return this.extensions.includes(ext);
+  }
+  setSymbolRegistry(registry) {
+    this.symbolRegistry = registry;
+  }
+  parse(source) {
+    return this.parser.parse(source);
+  }
+  buildSymbolId(filePath, name, kind) {
+    return `${filePath}::${name}::${kind}`;
+  }
+  nodeToLineRange(node) {
+    return {
+      startLine: node.startPosition.row,
+      endLine: node.endPosition.row,
+      startOffset: node.startIndex,
+      endOffset: node.endIndex
+    };
+  }
+  countCyclomaticComplexity(node, branchTypes) {
+    let complexity = 1;
+    const visit = (n) => {
+      if (branchTypes.includes(n.type)) {
+        complexity++;
+      }
+      for (let i = 0; i < n.childCount; i++) {
+        visit(n.child(i));
+      }
+    };
+    visit(node);
+    return complexity;
+  }
+};
+
+// src/go-adapter.ts
+var GO_BRANCH_TYPES = [
+  "if_statement",
+  "for_statement",
+  "expression_switch_statement",
+  "type_switch_statement",
+  "expression_case",
+  "type_case",
+  "select_statement",
+  "communication_case"
+];
+var GoAdapter = class extends TreeSitterAdapter {
+  extensions = [".go"];
+  constructor() {
+    super(GoLanguage);
+  }
+  async extractSymbols(filePath, source) {
+    try {
+      const tree = this.parse(source);
+      const symbols = [];
+      for (let i = 0; i < tree.rootNode.childCount; i++) {
+        const node = tree.rootNode.child(i);
+        if (node.type === "function_declaration") {
+          const name = node.childForFieldName("name")?.text;
+          if (!name || !this.isExported(name)) continue;
+          const range = this.nodeToLineRange(node);
+          symbols.push({
+            symbolId: this.buildSymbolId(filePath, name, "function"),
+            name,
+            kind: "function",
+            ...range
+          });
+        }
+        if (node.type === "method_declaration") {
+          const methodName = node.childForFieldName("name")?.text;
+          if (!methodName || !this.isExported(methodName)) continue;
+          const receiverType = this.extractReceiverType(node);
+          const qualifiedName = receiverType ? `${receiverType}.${methodName}` : methodName;
+          const range = this.nodeToLineRange(node);
+          symbols.push({
+            symbolId: this.buildSymbolId(filePath, qualifiedName, "method"),
+            name: qualifiedName,
+            kind: "method",
+            ...range
+          });
+        }
+        if (node.type === "type_declaration") {
+          this.extractTypeSymbols(node, filePath, symbols);
+        }
+      }
+      return symbols;
+    } catch (err) {
+      console.error(`[ctxo:go] Symbol extraction failed for ${filePath}: ${err.message}`);
+      return [];
+    }
+  }
+  async extractEdges(filePath, source) {
+    try {
+      const tree = this.parse(source);
+      const edges = [];
+      const firstExportedSymbol = this.findFirstExportedSymbolId(tree.rootNode, filePath);
+      if (!firstExportedSymbol) return edges;
+      for (let i = 0; i < tree.rootNode.childCount; i++) {
+        const node = tree.rootNode.child(i);
+        if (node.type === "import_declaration") {
+          this.extractImportEdges(node, filePath, firstExportedSymbol, edges);
+        }
+      }
+      return edges;
+    } catch (err) {
+      console.error(`[ctxo:go] Edge extraction failed for ${filePath}: ${err.message}`);
+      return [];
+    }
+  }
+  async extractComplexity(filePath, source) {
+    try {
+      const tree = this.parse(source);
+      const metrics = [];
+      for (let i = 0; i < tree.rootNode.childCount; i++) {
+        const node = tree.rootNode.child(i);
+        if (node.type === "function_declaration") {
+          const name = node.childForFieldName("name")?.text;
+          if (!name || !this.isExported(name)) continue;
+          metrics.push({
+            symbolId: this.buildSymbolId(filePath, name, "function"),
+            cyclomatic: this.countCyclomaticComplexity(node, GO_BRANCH_TYPES)
+          });
+        }
+        if (node.type === "method_declaration") {
+          const methodName = node.childForFieldName("name")?.text;
+          if (!methodName || !this.isExported(methodName)) continue;
+          const receiverType = this.extractReceiverType(node);
+          const qualifiedName = receiverType ? `${receiverType}.${methodName}` : methodName;
+          metrics.push({
+            symbolId: this.buildSymbolId(filePath, qualifiedName, "method"),
+            cyclomatic: this.countCyclomaticComplexity(node, GO_BRANCH_TYPES)
+          });
+        }
+      }
+      return metrics;
+    } catch (err) {
+      console.error(`[ctxo:go] Complexity extraction failed for ${filePath}: ${err.message}`);
+      return [];
+    }
+  }
+  // ── Private helpers ─────────────────────────────────────────
+  isExported(name) {
+    return name.length > 0 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase();
+  }
+  extractReceiverType(methodNode) {
+    const params = methodNode.child(1);
+    if (params?.type !== "parameter_list") return void 0;
+    for (let i = 0; i < params.childCount; i++) {
+      const param = params.child(i);
+      if (param.type === "parameter_declaration") {
+        const typeNode = param.childForFieldName("type");
+        if (typeNode) {
+          const text = typeNode.text;
+          return text.replace(/^\*/, "");
+        }
+      }
+    }
+    return void 0;
+  }
+  extractTypeSymbols(typeDecl, filePath, symbols) {
+    for (let i = 0; i < typeDecl.childCount; i++) {
+      const spec = typeDecl.child(i);
+      if (spec.type !== "type_spec") continue;
+      const name = spec.childForFieldName("name")?.text;
+      if (!name || !this.isExported(name)) continue;
+      const typeBody = spec.childForFieldName("type");
+      let kind = "type";
+      if (typeBody?.type === "struct_type") kind = "class";
+      else if (typeBody?.type === "interface_type") kind = "interface";
+      const range = this.nodeToLineRange(spec);
+      symbols.push({
+        symbolId: this.buildSymbolId(filePath, name, kind),
+        name,
+        kind,
+        ...range
+      });
+    }
+  }
+  extractImportEdges(importDecl, _filePath, fromSymbol, edges) {
+    const visit = (node) => {
+      if (node.type === "import_spec") {
+        const pathNode = node.childForFieldName("path") ?? node.child(0);
+        if (pathNode) {
+          const importPath = pathNode.text.replace(/"/g, "");
+          edges.push({
+            from: fromSymbol,
+            to: `${importPath}::${importPath.split("/").pop()}::variable`,
+            kind: "imports"
+          });
+        }
+      }
+      for (let i = 0; i < node.childCount; i++) {
+        visit(node.child(i));
+      }
+    };
+    visit(importDecl);
+  }
+  findFirstExportedSymbolId(rootNode, filePath) {
+    for (let i = 0; i < rootNode.childCount; i++) {
+      const node = rootNode.child(i);
+      if (node.type === "function_declaration") {
+        const name = node.childForFieldName("name")?.text;
+        if (name && this.isExported(name)) return this.buildSymbolId(filePath, name, "function");
+      }
+      if (node.type === "type_declaration") {
+        for (let j = 0; j < node.childCount; j++) {
+          const spec = node.child(j);
+          if (spec.type === "type_spec") {
+            const name = spec.childForFieldName("name")?.text;
+            if (name && this.isExported(name)) {
+              const typeBody = spec.childForFieldName("type");
+              const kind = typeBody?.type === "struct_type" ? "class" : typeBody?.type === "interface_type" ? "interface" : "type";
+              return this.buildSymbolId(filePath, name, kind);
+            }
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/index.ts
+var VERSION = "0.7.0-alpha.0";
+var plugin = {
+  apiVersion: "1",
+  id: "go",
+  name: "Go (tree-sitter)",
+  version: VERSION,
+  extensions: [".go"],
+  tier: "syntax",
+  createAdapter(_ctx) {
+    return new GoAdapter();
+  }
+};
+var index_default = plugin;
+export {
+  GoAdapter,
+  TreeSitterAdapter,
+  index_default as default,
+  plugin
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/go-adapter.ts","../src/tree-sitter-adapter.ts","../src/index.ts"],"sourcesContent":["import GoLanguage from 'tree-sitter-go';\nimport type { SyntaxNode } from 'tree-sitter';\nimport { TreeSitterAdapter } from './tree-sitter-adapter.js';\nimport type { SymbolNode, GraphEdge, ComplexityMetrics } from '@ctxo/plugin-api';\n\nconst GO_BRANCH_TYPES = [\n  'if_statement', 'for_statement',\n  'expression_switch_statement', 'type_switch_statement',\n  'expression_case', 'type_case',\n  'select_statement', 'communication_case',\n];\n\nexport class GoAdapter extends TreeSitterAdapter {\n  readonly extensions = ['.go'] as const;\n\n  constructor() {\n    super(GoLanguage);\n  }\n\n  async extractSymbols(filePath: string, source: string): Promise<SymbolNode[]> {\n    try {\n      const tree = this.parse(source);\n      const symbols: SymbolNode[] = [];\n\n      for (let i = 0; i < tree.rootNode.childCount; i++) {\n        const node = tree.rootNode.child(i)!;\n\n        if (node.type === 'function_declaration') {\n          const name = node.childForFieldName('name')?.text;\n          if (!name || !this.isExported(name)) continue;\n          const range = this.nodeToLineRange(node);\n          symbols.push({\n            symbolId: this.buildSymbolId(filePath, name, 'function'),\n            name,\n            kind: 'function',\n            ...range,\n          });\n        }\n\n        if (node.type === 'method_declaration') {\n          const methodName = node.childForFieldName('name')?.text;\n          if (!methodName || !this.isExported(methodName)) continue;\n          const receiverType = this.extractReceiverType(node);\n          const qualifiedName = receiverType ? `${receiverType}.${methodName}` : methodName;\n          const range = this.nodeToLineRange(node);\n          symbols.push({\n            symbolId: this.buildSymbolId(filePath, qualifiedName, 'method'),\n            name: qualifiedName,\n            kind: 'method',\n            ...range,\n          });\n        }\n\n        if (node.type === 'type_declaration') {\n          this.extractTypeSymbols(node, filePath, symbols);\n        }\n      }\n\n      return symbols;\n    } catch (err) {\n      console.error(`[ctxo:go] Symbol extraction failed for ${filePath}: ${(err as Error).message}`);\n      return [];\n    }\n  }\n\n  async extractEdges(filePath: string, source: string): Promise<GraphEdge[]> {\n    try {\n      const tree = this.parse(source);\n      const edges: GraphEdge[] = [];\n      const firstExportedSymbol = this.findFirstExportedSymbolId(tree.rootNode, filePath);\n      if (!firstExportedSymbol) return edges;\n\n      for (let i = 0; i < tree.rootNode.childCount; i++) {\n        const node = tree.rootNode.child(i)!;\n\n        if (node.type === 'import_declaration') {\n          this.extractImportEdges(node, filePath, firstExportedSymbol, edges);\n        }\n      }\n\n      return edges;\n    } catch (err) {\n      console.error(`[ctxo:go] Edge extraction failed for ${filePath}: ${(err as Error).message}`);\n      return [];\n    }\n  }\n\n  async extractComplexity(filePath: string, source: string): Promise<ComplexityMetrics[]> {\n    try {\n      const tree = this.parse(source);\n      const metrics: ComplexityMetrics[] = [];\n\n      for (let i = 0; i < tree.rootNode.childCount; i++) {\n        const node = tree.rootNode.child(i)!;\n\n        if (node.type === 'function_declaration') {\n          const name = node.childForFieldName('name')?.text;\n          if (!name || !this.isExported(name)) continue;\n          metrics.push({\n            symbolId: this.buildSymbolId(filePath, name, 'function'),\n            cyclomatic: this.countCyclomaticComplexity(node, GO_BRANCH_TYPES),\n          });\n        }\n\n        if (node.type === 'method_declaration') {\n          const methodName = node.childForFieldName('name')?.text;\n          if (!methodName || !this.isExported(methodName)) continue;\n          const receiverType = this.extractReceiverType(node);\n          const qualifiedName = receiverType ? `${receiverType}.${methodName}` : methodName;\n          metrics.push({\n            symbolId: this.buildSymbolId(filePath, qualifiedName, 'method'),\n            cyclomatic: this.countCyclomaticComplexity(node, GO_BRANCH_TYPES),\n          });\n        }\n      }\n\n      return metrics;\n    } catch (err) {\n      console.error(`[ctxo:go] Complexity extraction failed for ${filePath}: ${(err as Error).message}`);\n      return [];\n    }\n  }\n\n  // ── Private helpers ─────────────────────────────────────────\n\n  private isExported(name: string): boolean {\n    return name.length > 0 && name[0]! === name[0]!.toUpperCase() && name[0]! !== name[0]!.toLowerCase();\n  }\n\n  private extractReceiverType(methodNode: SyntaxNode): string | undefined {\n    // method_declaration has parameter_list as first child (receiver)\n    const params = methodNode.child(1);\n    if (params?.type !== 'parameter_list') return undefined;\n\n    for (let i = 0; i < params.childCount; i++) {\n      const param = params.child(i)!;\n      if (param.type === 'parameter_declaration') {\n        // Find type identifier — may be pointer (*Type) or plain (Type)\n        const typeNode = param.childForFieldName('type');\n        if (typeNode) {\n          const text = typeNode.text;\n          return text.replace(/^\\*/, '');\n        }\n      }\n    }\n    return undefined;\n  }\n\n  private extractTypeSymbols(typeDecl: SyntaxNode, filePath: string, symbols: SymbolNode[]): void {\n    for (let i = 0; i < typeDecl.childCount; i++) {\n      const spec = typeDecl.child(i)!;\n      if (spec.type !== 'type_spec') continue;\n\n      const name = spec.childForFieldName('name')?.text;\n      if (!name || !this.isExported(name)) continue;\n\n      // Determine kind from the type body\n      const typeBody = spec.childForFieldName('type');\n      let kind: 'class' | 'interface' | 'type' = 'type';\n      if (typeBody?.type === 'struct_type') kind = 'class';\n      else if (typeBody?.type === 'interface_type') kind = 'interface';\n\n      const range = this.nodeToLineRange(spec);\n      symbols.push({\n        symbolId: this.buildSymbolId(filePath, name, kind),\n        name,\n        kind,\n        ...range,\n      });\n    }\n  }\n\n  private extractImportEdges(\n    importDecl: SyntaxNode,\n    _filePath: string,\n    fromSymbol: string,\n    edges: GraphEdge[],\n  ): void {\n    const visit = (node: SyntaxNode) => {\n      if (node.type === 'import_spec') {\n        const pathNode = node.childForFieldName('path') ?? node.child(0);\n        if (pathNode) {\n          const importPath = pathNode.text.replace(/\"/g, '');\n          edges.push({\n            from: fromSymbol,\n            to: `${importPath}::${importPath.split('/').pop()}::variable`,\n            kind: 'imports',\n          });\n        }\n      }\n      for (let i = 0; i < node.childCount; i++) {\n        visit(node.child(i)!);\n      }\n    };\n    visit(importDecl);\n  }\n\n  private findFirstExportedSymbolId(rootNode: SyntaxNode, filePath: string): string | undefined {\n    for (let i = 0; i < rootNode.childCount; i++) {\n      const node = rootNode.child(i)!;\n\n      if (node.type === 'function_declaration') {\n        const name = node.childForFieldName('name')?.text;\n        if (name && this.isExported(name)) return this.buildSymbolId(filePath, name, 'function');\n      }\n      if (node.type === 'type_declaration') {\n        for (let j = 0; j < node.childCount; j++) {\n          const spec = node.child(j)!;\n          if (spec.type === 'type_spec') {\n            const name = spec.childForFieldName('name')?.text;\n            if (name && this.isExported(name)) {\n              const typeBody = spec.childForFieldName('type');\n              const kind = typeBody?.type === 'struct_type' ? 'class' : typeBody?.type === 'interface_type' ? 'interface' : 'type';\n              return this.buildSymbolId(filePath, name, kind);\n            }\n          }\n        }\n      }\n    }\n    return undefined;\n  }\n}\n","import Parser from 'tree-sitter';\nimport type { Tree, SyntaxNode } from 'tree-sitter';\ntype Language = Parameters<InstanceType<typeof Parser>['setLanguage']>[0];\nimport { extname } from 'node:path';\nimport type { SymbolNode, GraphEdge, ComplexityMetrics, SymbolKind, ILanguageAdapter } from '@ctxo/plugin-api';\n\nexport abstract class TreeSitterAdapter implements ILanguageAdapter {\n  abstract readonly extensions: readonly string[];\n  readonly tier = 'syntax' as const;\n\n  protected parser: Parser;\n  protected symbolRegistry = new Map<string, SymbolKind>();\n\n  constructor(language: Language) {\n    this.parser = new Parser();\n    this.parser.setLanguage(language);\n  }\n\n  isSupported(filePath: string): boolean {\n    const ext = extname(filePath).toLowerCase();\n    return (this.extensions as readonly string[]).includes(ext);\n  }\n\n  setSymbolRegistry(registry: Map<string, SymbolKind>): void {\n    this.symbolRegistry = registry;\n  }\n\n  protected parse(source: string): Tree {\n    return this.parser.parse(source);\n  }\n\n  protected buildSymbolId(filePath: string, name: string, kind: SymbolKind): string {\n    return `${filePath}::${name}::${kind}`;\n  }\n\n  protected nodeToLineRange(node: SyntaxNode): {\n    startLine: number;\n    endLine: number;\n    startOffset: number;\n    endOffset: number;\n  } {\n    return {\n      startLine: node.startPosition.row,\n      endLine: node.endPosition.row,\n      startOffset: node.startIndex,\n      endOffset: node.endIndex,\n    };\n  }\n\n  protected countCyclomaticComplexity(node: SyntaxNode, branchTypes: string[]): number {\n    let complexity = 1;\n    const visit = (n: SyntaxNode) => {\n      if (branchTypes.includes(n.type)) {\n        complexity++;\n      }\n      for (let i = 0; i < n.childCount; i++) {\n        visit(n.child(i)!);\n      }\n    };\n    visit(node);\n    return complexity;\n  }\n\n  abstract extractSymbols(filePath: string, source: string): Promise<SymbolNode[]>;\n  abstract extractEdges(filePath: string, source: string): Promise<GraphEdge[]>;\n  abstract extractComplexity(filePath: string, source: string): Promise<ComplexityMetrics[]>;\n}\n","import type { CtxoLanguagePlugin, PluginContext, ILanguageAdapter } from '@ctxo/plugin-api';\nimport { GoAdapter } from './go-adapter.js';\n\nexport { GoAdapter } from './go-adapter.js';\nexport { TreeSitterAdapter } from './tree-sitter-adapter.js';\n\nconst VERSION = '0.7.0-alpha.0';\n\nexport const plugin: CtxoLanguagePlugin = {\n  apiVersion: '1',\n  id: 'go',\n  name: 'Go (tree-sitter)',\n  version: VERSION,\n  extensions: ['.go'],\n  tier: 'syntax',\n  createAdapter(_ctx: PluginContext): ILanguageAdapter {\n    return new GoAdapter();\n  },\n};\n\nexport default plugin;\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@ctxo/lang-go",
+  "version": "0.7.0-alpha.0",
+  "description": "Ctxo Go language plugin (tree-sitter, syntax tier)",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "keywords": [
+    "ctxo",
+    "ctxo-plugin",
+    "language-plugin",
+    "go",
+    "golang",
+    "tree-sitter"
+  ],
+  "author": "Alper Hankendi",
+  "license": "MIT",
+  "dependencies": {
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-go": "^0.23.4"
+  },
+  "peerDependencies": {
+    "@ctxo/plugin-api": "^0.7.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.3",
+    "@ctxo/plugin-api": "0.7.0-alpha.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:unit": "vitest run"
+  }
+}