Refactor to keep core provider agnostic

Author: savannahostrowski

src/core/analyzer.ts

@@ -2,7 +2,6 @@
  * Analyzer module to extract FastAPI-related information from syntax trees.
  */
 
-import * as vscode from "vscode"
 import type { Tree } from "web-tree-sitter"
 import {
   decoratorExtractor,
@@ -12,6 +11,7 @@ import {
   mountExtractor,
   routerExtractor,
 } from "./extractors.js"
+import type { FileSystem } from "./filesystem"
 import type { FileAnalysis } from "./internal"
 import type { Parser } from "./parser.js"
 
@@ -46,19 +46,20 @@ export function analyzeTree(tree: Tree, filePath: string): FileAnalysis {
   return { filePath, routes, routers, includeRouters, mounts, imports }
 }
 
-/** Analyze a file given its URI and a parser instance */
+/** Analyze a file given its URI string and a parser instance */
 export async function analyzeFile(
-  fileUri: vscode.Uri,
+  fileUri: string,
   parser: Parser,
+  fs: FileSystem,
 ): Promise<FileAnalysis | null> {
   try {
-    const content = await vscode.workspace.fs.readFile(fileUri)
+    const content = await fs.readFile(fileUri)
     const code = new TextDecoder().decode(content)
     const tree = parser.parse(code)
     if (!tree) {
       return null
     }
-    return analyzeTree(tree, fileUri.fsPath)
+    return analyzeTree(tree, fileUri)
   } catch {
     return null
   }

src/core/filesystem.ts

@@ -0,0 +1,23 @@
+/**
+ * Abstract filesystem interface for platform-agnostic file operations.
+ * This allows the core logic to work with any filesystem implementation
+ * (VS Code virtual filesystem, Node.js fs, Zed, etc.).
+ */
+
+/**
+ * Filesystem abstraction for reading files and checking existence.
+ * Implementations should use URI strings as identifiers.
+ */
+export interface FileSystem {
+  /** Read a file's contents as bytes */
+  readFile(uri: string): Promise<Uint8Array>
+
+  /** Check if a file or directory exists */
+  exists(uri: string): Promise<boolean>
+
+  /** Join path segments to a base URI */
+  joinPath(base: string, ...segments: string[]): string
+
+  /** Get the parent directory of a URI */
+  dirname(uri: string): string
+}

src/core/importResolver.ts

@@ -11,10 +11,8 @@
  * 3. module/ without __init__.py (namespace package)
  */
 
-import * as vscode from "vscode"
-import { analyzeFile } from "./analyzer"
+import type { FileSystem } from "./filesystem"
 import type { ImportInfo } from "./internal"
-import type { Parser } from "./parser"
 import { uriDirname } from "./pathUtils"
 
 /**
@@ -23,20 +21,14 @@ import { uriDirname } from "./pathUtils"
  */
 const fileExistsCache = new Map<string, boolean>()
 
-async function cachedExists(uri: vscode.Uri): Promise<boolean> {
-  const key = uri.toString()
-  const cached = fileExistsCache.get(key)
+async function cachedExists(uri: string, fs: FileSystem): Promise<boolean> {
+  const cached = fileExistsCache.get(uri)
   if (cached !== undefined) {
     return cached
   }
-  try {
-    await vscode.workspace.fs.stat(uri)
-    fileExistsCache.set(key, true)
-    return true
-  } catch {
-    fileExistsCache.set(key, false)
-    return false
-  }
+  const exists = await fs.exists(uri)
+  fileExistsCache.set(uri, exists)
+  return exists
 }
 
 /** Clears the file existence cache. Call when files may have changed. */
@@ -50,16 +42,17 @@ export function clearImportCache(): void {
  * (matching Python's import resolution order).
  */
 async function resolvePythonModule(
-  baseUri: vscode.Uri,
-): Promise<vscode.Uri | null> {
+  baseUri: string,
+  fs: FileSystem,
+): Promise<string | null> {
   // Try module.py
-  const pyUri = baseUri.with({ path: `${baseUri.path}.py` })
-  if (await cachedExists(pyUri)) {
+  const pyUri = `${baseUri}.py`
+  if (await cachedExists(pyUri, fs)) {
     return pyUri
   }
   // Try module/__init__.py
-  const initUri = vscode.Uri.joinPath(baseUri, "__init__.py")
-  if (await cachedExists(initUri)) {
+  const initUri = fs.joinPath(baseUri, "__init__.py")
+  if (await cachedExists(initUri, fs)) {
     return initUri
   }
   return null
@@ -87,10 +80,11 @@ function findImportByExportedName(
  */
 function modulePathToDir(
   importInfo: Pick<ImportInfo, "modulePath" | "isRelative" | "relativeDots">,
-  currentFileUri: vscode.Uri,
-  projectRootUri: vscode.Uri,
-): vscode.Uri {
-  let baseDirUri: vscode.Uri
+  currentFileUri: string,
+  projectRootUri: string,
+  fs: FileSystem,
+): string {
+  let baseDirUri: string
   if (importInfo.isRelative) {
     // For relative imports, go up 'relativeDots' directories from current file
     baseDirUri = uriDirname(currentFileUri)
@@ -102,7 +96,7 @@ function modulePathToDir(
   }
 
   if (importInfo.modulePath) {
-    return vscode.Uri.joinPath(baseDirUri, ...importInfo.modulePath.split("."))
+    return fs.joinPath(baseDirUri, ...importInfo.modulePath.split("."))
   }
   return baseDirUri
 }
@@ -118,61 +112,68 @@ function modulePathToDir(
  */
 export async function resolveImport(
   importInfo: Pick<ImportInfo, "modulePath" | "isRelative" | "relativeDots">,
-  currentFileUri: vscode.Uri,
-  projectRootUri: vscode.Uri,
-): Promise<vscode.Uri | null> {
+  currentFileUri: string,
+  projectRootUri: string,
+  fs: FileSystem,
+): Promise<string | null> {
   const resolvedUri = modulePathToDir(
     importInfo,
     currentFileUri,
     projectRootUri,
+    fs,
   )
-  return resolvePythonModule(resolvedUri)
+  return resolvePythonModule(resolvedUri, fs)
 }
 
 /**
  * Resolves a named import to its file URI.
  * For example, from .routes import users
  * will try to resolve to routes/users.py
+ *
+ * @param analyzeFileFn - Function to analyze a file (injected to avoid circular dependency)
  */
 export async function resolveNamedImport(
   importInfo: Pick<
     ImportInfo,
     "modulePath" | "names" | "isRelative" | "relativeDots"
   >,
-  currentFileUri: vscode.Uri,
-  projectRootUri: vscode.Uri,
-  parser?: Parser,
-): Promise<vscode.Uri | null> {
+  currentFileUri: string,
+  projectRootUri: string,
+  fs: FileSystem,
+  analyzeFileFn?: (uri: string) => Promise<{ imports: ImportInfo[] } | null>,
+): Promise<string | null> {
   const baseUri = await resolveImport(
     importInfo,
     currentFileUri,
     projectRootUri,
+    fs,
   )
 
   // Calculate base directory for named import resolution.
   // For namespace packages (directories without __init__.py), baseUri will be null,
   // so we compute the directory path directly from the module path.
   const baseDirUri = baseUri
     ? uriDirname(baseUri)
-    : modulePathToDir(importInfo, currentFileUri, projectRootUri)
+    : modulePathToDir(importInfo, currentFileUri, projectRootUri, fs)
 
   for (const name of importInfo.names) {
     // Try direct file: from .routes import users -> routes/users.py
-    const namedUri = vscode.Uri.joinPath(baseDirUri, ...name.split("."))
-    const resolved = await resolvePythonModule(namedUri)
+    const namedUri = fs.joinPath(baseDirUri, ...name.split("."))
+    const resolved = await resolvePythonModule(namedUri, fs)
     if (resolved) {
       return resolved
     }
 
     // Try re-exports: from .routes import users where routes/__init__.py re-exports users
-    if (baseUri?.path.endsWith("__init__.py") && parser) {
-      const analysis = await analyzeFile(baseUri, parser)
+    if (baseUri?.endsWith("__init__.py") && analyzeFileFn) {
+      const analysis = await analyzeFileFn(baseUri)
       const imp = analysis && findImportByExportedName(analysis.imports, name)
       if (imp) {
         const reExportResolved = await resolveImport(
           imp,
           baseUri,
           projectRootUri,
+          fs,
         )
         if (reExportResolved) {
           return reExportResolved
@@ -192,22 +193,28 @@ export async function resolveNamedImport(
  * For example, if integrations/__init__.py contains:
  *   from .router import router as router
  * This will return the path to integrations/router.py
+ *
+ * @param analyzeFileFn - Function to analyze a file (injected to avoid circular dependency)
  */
 export async function resolveRouterFromInit(
-  initFileUri: vscode.Uri,
-  projectRootUri: vscode.Uri,
-  parser: Parser,
-): Promise<vscode.Uri | null> {
-  if (!initFileUri.path.endsWith("__init__.py")) {
+  initFileUri: string,
+  projectRootUri: string,
+  fs: FileSystem,
+  analyzeFileFn: (uri: string) => Promise<{
+    imports: ImportInfo[]
+    routers: { variableName: string }[]
+  } | null>,
+): Promise<string | null> {
+  if (!initFileUri.endsWith("__init__.py")) {
     return null
   }
 
-  const analysis = await analyzeFile(initFileUri, parser)
+  const analysis = await analyzeFileFn(initFileUri)
   // If file has routers defined, no need to follow re-exports
   if (!analysis || analysis.routers.length > 0) {
     return null
   }
 
   const imp = findImportByExportedName(analysis.imports, "router")
-  return imp ? resolveImport(imp, initFileUri, projectRootUri) : null
+  return imp ? resolveImport(imp, initFileUri, projectRootUri, fs) : null
 }

src/core/index.ts

@@ -4,8 +4,11 @@
  */
 
 export { analyzeFile, analyzeTree } from "./analyzer"
+export type { FileSystem } from "./filesystem"
+export { clearImportCache } from "./importResolver"
 export type { FileAnalysis } from "./internal"
 export { Parser } from "./parser"
+export { findProjectRoot } from "./pathUtils"
 export { buildRouterGraph, type RouterNode } from "./routerResolver"
 export { routerNodeToAppDefinition } from "./transformer"
 export type {

src/core/parser.ts

@@ -2,32 +2,43 @@
  * Parser service using Web Tree Sitter to parse Python code.
  */
 
-import * as vscode from "vscode"
 import { Language, Parser as TreeSitterParser } from "web-tree-sitter"
 
 export class Parser {
   private parser: TreeSitterParser | null = null
-  async init(wasmPaths: { core: vscode.Uri; python: vscode.Uri }) {
+
+  /**
+   * Initialize the parser with WASM binaries.
+   * @param wasmBinaries.core - The web-tree-sitter.wasm binary
+   * @param wasmBinaries.python - The tree-sitter-python.wasm binary
+   */
+  async init(wasmBinaries: { core: Uint8Array; python: Uint8Array }) {
     if (this.parser) {
       return
     }
 
-    // Read WASM files via VS Code's virtual filesystem API
-    const [wasmBinary, pythonWasmBinary] = await Promise.all([
-      vscode.workspace.fs.readFile(wasmPaths.core),
-      vscode.workspace.fs.readFile(wasmPaths.python),
-    ])
+    // Pre-compile the WASM module from the binary
+    const wasmModule = await WebAssembly.compile(wasmBinaries.core)
 
-    // Initialize tree-sitter with the core WASM binary
+    // Use instantiateWasm to provide custom WASM instantiation.
+    // This bypasses tree-sitter's default URL-based loading which fails
+    // in VS Code web extensions where import.meta.url is not available.
     await TreeSitterParser.init({
-      locateFile: () => wasmPaths.core.toString(),
-      wasmBinary,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      instantiateWasm(imports: any, successCallback: any) {
+        WebAssembly.instantiate(wasmModule, imports).then(
+          (instance: WebAssembly.Instance) => {
+            successCallback(instance, wasmModule)
+          },
+        )
+        return {}
+      },
     })
 
     const parser = new TreeSitterParser()
 
     // Load Python language from WASM binary
-    const pythonLanguage = await Language.load(new Uint8Array(pythonWasmBinary))
+    const pythonLanguage = await Language.load(wasmBinaries.python)
     parser.setLanguage(pythonLanguage)
 
     this.parser = parser