@cgasgarth/opencode-for-rust 1.1.7 → 1.1.9-next.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgasgarth/opencode-for-rust",
-  "version": "1.1.7",
+  "version": "1.1.9-next.1",
   "description": "OpenCode plugin for Rust",
   "author": {
     "name": "Sisyphus",
@@ -9,8 +9,8 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./cgasgarth/opencode-for-rust/index.d.ts",
+      "default": "./cgasgarth/opencode-for-rust/index.js"
     }
   },
   "repository": {
@@ -22,14 +22,13 @@
     "provenance": true
   },
   "files": [
-    "dist",
-    "src/version.ts"
+    "cgasgarth"
   ],
   "dependencies": {
-    "@opencode-ai/plugin": "1.0.85"
+    "@opencode-ai/plugin": "1.0.85",
+    "zod": "^4.0.0"
   },
   "devDependencies": {
-    "zod": "^4.0.0",
     "@eslint/js": "^9.39.1",
     "@types/bun": "latest",
     "@types/node": "^20.12.7",
@@ -50,7 +49,7 @@
   "scripts": {
     "test": "bun test tests/",
     "typecheck": "tsc --noEmit",
-    "build": "esbuild ./src/index.ts --bundle --format=esm --platform=node --outdir=dist --external:@opencode-ai/plugin --external:zod && tsc --project tsconfig.build.json",
+    "build": "esbuild ./src/index.ts --bundle --format=esm --platform=node --outdir=cgasgarth/opencode-for-rust --external:@opencode-ai/plugin --external:zod && tsc --project tsconfig.build.json",
     "lint": "eslint src --max-warnings 0",
     "format": "prettier --check .",
     "prepare": "husky"

package/dist/index.js

@@ -1,360 +0,0 @@
-// src/index.ts
-import { tool } from "@opencode-ai/plugin";
-
-// src/lib/regex-extractor.ts
-import * as fs from "fs";
-var PATTERNS = [
-  {
-    kind: "struct",
-    regex: /(?:^|\n)(\s*(?:\/\/\/.*\n)*)(\s*pub(?:\([^)]*\))?\s+)?struct\s+(\w+)(?:<[^>]*>)?(?:\s*\{|\s*;)/g,
-    useBodyExtractor: true
-  },
-  {
-    kind: "enum",
-    regex: /(?:^|\n)(\s*(?:\/\/\/.*\n)*)(\s*pub(?:\([^)]*\))?\s+)?enum\s+(\w+)(?:<[^>]*>)?(?:\s*\{)/g,
-    useBodyExtractor: true
-  },
-  {
-    kind: "trait",
-    regex: /(?:^|\n)(\s*(?:\/\/\/.*\n)*)(\s*pub(?:\([^)]*\))?\s+)?trait\s+(\w+)(?:<[^>]*>)?(?:\s*\{)/g,
-    useBodyExtractor: true
-  },
-  {
-    kind: "function",
-    regex: /(?:^|\n)(\s*(?:\/\/\/.*\n)*)(\s*pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+(\w+)(?:<[^>]*>)?\s*\([^)]*\)(?:\s*->\s*[^{]+)?(?:\s*where[^{]*)?\s*\{/g,
-    useBodyExtractor: true
-  },
-  {
-    kind: "type_alias",
-    regex: /(?:^|\n)(\s*(?:\/\/\/.*\n)*)(\s*pub(?:\([^)]*\))?\s+)?type\s+(\w+)(?:<[^>]*>)?\s*=\s*[^;]+;/g
-  },
-  {
-    kind: "const",
-    regex: /(?:^|\n)(\s*(?:\/\/\/.*\n)*)(\s*pub(?:\([^)]*\))?\s+)?const\s+(\w+)\s*:\s*[^=]+=\s*[^;]+;/g
-  },
-  {
-    kind: "impl",
-    regex: /(?:^|\n)(\s*)impl(?:<[^>]*>)?\s+(?:(\w+)\s+for\s+)?(\w+)(?:<[^>]*>)?(?:\s*where[^{]*)?\s*\{/g,
-    useBodyExtractor: true
-  }
-];
-
-class RegexRustTypeExtractor {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  async extract(filePath, content) {
-    const fileContent = content || await fs.promises.readFile(filePath, "utf-8");
-    const types = [];
-    for (const { kind, regex, useBodyExtractor } of PATTERNS) {
-      regex.lastIndex = 0;
-      let match;
-      while ((match = regex.exec(fileContent)) !== null) {
-        const docComment = match[1]?.trim() || undefined;
-        const visibility = match[2]?.trim();
-        const name = match[3];
-        const exported = visibility?.startsWith("pub") ?? false;
-        const matchStart = match.index + (match[0].startsWith(`
-`) ? 1 : 0);
-        const lineStart = fileContent.substring(0, matchStart).split(`
-`).length;
-        let body = match[0].startsWith(`
-`) ? match[0].substring(1) : match[0];
-        if (kind === "struct" && body.trim().endsWith(";")) {} else if (useBodyExtractor) {
-          const braceIndex = fileContent.indexOf("{", matchStart);
-          if (braceIndex !== -1) {
-            body = this.extractFullBody(fileContent, matchStart);
-          }
-        }
-        const lineEnd = lineStart + body.split(`
-`).length - 1;
-        const signature = body.split(`
-`)[0];
-        types.push({
-          name,
-          kind,
-          signature,
-          docComment: docComment || undefined,
-          exported,
-          filePath,
-          lineStart,
-          lineEnd,
-          body
-        });
-      }
-    }
-    return types;
-  }
-  extractFullBody(content, startIndex) {
-    let braceCount = 0;
-    let started = false;
-    let endIndex = startIndex;
-    for (let i = startIndex;i < content.length; i++) {
-      const char = content[i];
-      if (char === "{") {
-        braceCount++;
-        started = true;
-      } else if (char === "}") {
-        braceCount--;
-        if (started && braceCount === 0) {
-          endIndex = i + 1;
-          break;
-        }
-      }
-    }
-    return content.substring(startIndex, endIndex);
-  }
-}
-
-// src/lib/lookup.ts
-import * as path from "path";
-import * as fs2 from "fs/promises";
-async function* walkDir(dir) {
-  const entries = await fs2.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      yield* walkDir(fullPath);
-    } else if (entry.isFile() && entry.name.endsWith(".rs")) {
-      yield fullPath;
-    }
-  }
-}
-
-class RustTypeLookup {
-  directory;
-  config;
-  extractor;
-  cache = new Map;
-  lastScanTime = 0;
-  constructor(directory, config) {
-    this.directory = directory;
-    this.config = config;
-    this.extractor = new RegexRustTypeExtractor(config);
-  }
-  async findType(name) {
-    await this.ensureCache();
-    return this.cache.get(name);
-  }
-  async listTypeNames() {
-    await this.ensureCache();
-    return Array.from(this.cache.keys());
-  }
-  async refresh() {
-    this.cache.clear();
-    for await (const absolutePath of walkDir(this.directory)) {
-      const relativePath = path.relative(this.directory, absolutePath);
-      if (this.shouldExclude(relativePath))
-        continue;
-      try {
-        const types = await this.extractor.extract(absolutePath);
-        for (const type of types) {
-          if (type.name) {
-            const existing = this.cache.get(type.name);
-            if (!existing || this.getPriority(type.kind) < this.getPriority(existing.kind)) {
-              this.cache.set(type.name, type);
-            }
-          }
-        }
-      } catch {
-        continue;
-      }
-    }
-    this.lastScanTime = Date.now();
-  }
-  getPriority(kind) {
-    const priority = {
-      struct: 1,
-      enum: 1,
-      trait: 1,
-      type_alias: 1,
-      const: 2,
-      function: 3,
-      macro: 4,
-      impl: 10
-    };
-    return priority[kind] || 99;
-  }
-  async ensureCache() {
-    if (this.cache.size === 0) {
-      await this.refresh();
-    }
-  }
-  shouldExclude(filePath) {
-    return this.config.excludePatterns.some((pattern) => filePath.includes(pattern));
-  }
-}
-
-// src/lib/formatter.ts
-class RustContentFormatter {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  formatInjectedTypes(types) {
-    if (types.length === 0)
-      return "";
-    const sortedTypes = this.sortTypes(types);
-    const startComment = "/" + "* Injected Rust Types *" + "/";
-    const endComment = "/" + "* End Injected Rust Types *" + "/";
-    const header = `
-
-` + startComment + `
-`;
-    const formattedTypes = sortedTypes.map((type) => {
-      let output = "";
-      if (type.docComment) {
-        output += `${type.docComment}
-`;
-      }
-      output += type.body || type.signature;
-      return output;
-    });
-    return header + formattedTypes.join(`
-
-`) + `
-` + endComment + `
-`;
-  }
-  sortTypes(types) {
-    return types.sort((a, b) => {
-      const priority = {
-        struct: 1,
-        enum: 2,
-        trait: 3,
-        type_alias: 4,
-        function: 5,
-        impl: 6,
-        const: 7,
-        macro: 8
-      };
-      const pA = priority[a.kind] || 99;
-      const pB = priority[b.kind] || 99;
-      if (pA !== pB)
-        return pA - pB;
-      return a.name.localeCompare(b.name);
-    });
-  }
-}
-
-// src/index.ts
-import { appendFileSync } from "fs";
-var DEBUG_LOG = "/tmp/opencode-rust-plugin.log";
-function debugLog(msg) {
-  const timestamp = new Date().toISOString();
-  appendFileSync(DEBUG_LOG, `[${timestamp}] ${msg}
-`);
-}
-var RustPlugin = async (context) => {
-  debugLog(`Plugin initializing with context: ${JSON.stringify(context)}`);
-  const config = {
-    enabled: true,
-    debug: true,
-    budget: 50,
-    excludePatterns: [],
-    imports: false
-  };
-  const directory = context.directory || process.cwd();
-  debugLog(`Using directory: ${directory}`);
-  const lookup = new RustTypeLookup(directory, config);
-  const formatter = new RustContentFormatter(config);
-  const extractor = new RegexRustTypeExtractor(config);
-  debugLog("Created lookup, formatter, extractor");
-  if (!tool) {
-    debugLog('FATAL: @opencode-ai/plugin "tool" export is undefined');
-  }
-  const z = tool.schema;
-  if (!z) {
-    debugLog("FATAL: tool.schema is undefined - cannot define Zod schemas");
-  } else {
-    debugLog("tool.schema is available");
-  }
-  try {
-    await lookup.refresh();
-    debugLog("Initial refresh completed");
-  } catch (e) {
-    debugLog(`Initial refresh failed: ${e}`);
-  }
-  const hooks = {
-    tool: {
-      lookup_type: tool({
-        description: "Find a Rust type definition by name",
-        args: {
-          name: z.string().describe("The name of the type to look up")
-        },
-        async execute(args, _context) {
-          debugLog(`lookup_type called with: ${JSON.stringify(args)}`);
-          try {
-            await lookup.refresh();
-            debugLog("lookup_type: refresh done");
-            const type = await lookup.findType(args.name);
-            debugLog(`lookup_type: findType result: ${type ? "found" : "not found"}`);
-            if (!type) {
-              return `Type '${args.name}' not found`;
-            }
-            const result = formatter.formatInjectedTypes([type]);
-            debugLog(`lookup_type: returning ${result.length} chars`);
-            return result;
-          } catch (e) {
-            debugLog(`lookup_type error: ${e}`);
-            throw e;
-          }
-        }
-      }),
-      list_types: tool({
-        description: "List all available Rust type names in the project",
-        args: {
-          ignore: z.boolean().optional().describe("Ignore this argument (legacy support)")
-        },
-        async execute(_args, _context) {
-          debugLog("list_types called");
-          try {
-            await lookup.refresh();
-            debugLog("list_types: refresh done");
-            const names = await lookup.listTypeNames();
-            debugLog(`list_types: found ${names.length} types`);
-            if (names.length === 0) {
-              return "No Rust types found in project";
-            }
-            return names.join(`
-`);
-          } catch (e) {
-            debugLog(`list_types error: ${e}`);
-            throw e;
-          }
-        }
-      })
-    },
-    "tool.execute.after": async (input, output) => {
-      debugLog(`tool.execute.after: tool=${input.tool}`);
-      if (input.tool !== "read") {
-        return;
-      }
-      const metadata = output.metadata;
-      const filePath = metadata?.filePath;
-      debugLog(`tool.execute.after: filePath=${filePath}`);
-      if (!filePath || !filePath.endsWith(".rs")) {
-        return;
-      }
-      try {
-        const types = await extractor.extract(filePath);
-        debugLog(`tool.execute.after: extracted ${types.length} types`);
-        const formatted = formatter.formatInjectedTypes(types);
-        if (formatted) {
-          output.output = output.output + formatted;
-          debugLog(`tool.execute.after: appended ${formatted.length} chars`);
-        }
-      } catch (error) {
-        debugLog(`tool.execute.after error: ${error}`);
-      }
-    }
-  };
-  debugLog("Hooks created, returning");
-  return hooks;
-};
-var src_default = RustPlugin;
-export {
-  src_default as default,
-  RustPlugin
-};