route-intelligence-vscode 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# route-intelligence-vscode
+
+## 1.1.0
+
+### Minor Changes
+
+- start of my project
+
+### Patch Changes
+
+- Updated dependencies
+- Updated dependencies
+- Updated dependencies
+  - @route-intelligence/core@2.0.0
+  - @route-intelligence/next@2.0.0
+  - @route-intelligence/shared@2.0.0

package/dist/extension.d.ts

@@ -0,0 +1,6 @@
+import * as vscode from 'vscode';
+
+declare function activate(context: vscode.ExtensionContext): void;
+declare function deactivate(): void;
+
+export { activate, deactivate };

package/dist/extension.js

@@ -0,0 +1,186 @@
+// src/extension.ts
+import { createAnalyzer, exportJson } from "@route-intelligence/core";
+import { NextPlugin } from "@route-intelligence/next";
+import * as vscode from "vscode";
+var cachedGraph = null;
+var diagnosticCollection = vscode.languages.createDiagnosticCollection("route-intelligence");
+async function analyzeWorkspace() {
+  const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+  if (!workspaceRoot) return null;
+  const analyzer = createAnalyzer({
+    root: workspaceRoot,
+    plugins: [NextPlugin()],
+    include: ["app/**", "pages/**", "src/**", "middleware.ts"],
+    exclude: ["**/node_modules/**", "**/.next/**"]
+  });
+  const result = await analyzer.analyze();
+  cachedGraph = JSON.parse(
+    exportJson(result.graph, workspaceRoot)
+  );
+  updateDiagnostics(result.diagnostics);
+  return cachedGraph;
+}
+function updateDiagnostics(diagnostics) {
+  diagnosticCollection.clear();
+  const byFile = /* @__PURE__ */ new Map();
+  for (const d of diagnostics) {
+    if (!d.loc?.filePath) continue;
+    const diags = byFile.get(d.loc.filePath) ?? [];
+    diags.push(
+      new vscode.Diagnostic(
+        new vscode.Range(
+          Math.max(0, d.loc.line - 1),
+          d.loc.column,
+          Math.max(0, d.loc.line - 1),
+          d.loc.column + 1
+        ),
+        d.message,
+        d.severity === "error" ? vscode.DiagnosticSeverity.Error : vscode.DiagnosticSeverity.Warning
+      )
+    );
+    byFile.set(d.loc.filePath, diags);
+  }
+  for (const [file, diags] of byFile) {
+    diagnosticCollection.set(vscode.Uri.file(file), diags);
+  }
+}
+var RouteTreeProvider = class {
+  _onDidChangeTreeData = new vscode.EventEmitter();
+  onDidChangeTreeData = this._onDidChangeTreeData.event;
+  refresh() {
+    this._onDidChangeTreeData.fire(void 0);
+  }
+  getTreeItem(element) {
+    return element;
+  }
+  getChildren(element) {
+    if (!cachedGraph) return [];
+    const graph = cachedGraph;
+    if (!element) {
+      return graph.nodes.filter((n) => n.attributes.type === "route").map(
+        (n) => new RouteTreeItem(n.attributes.path, n.id, vscode.TreeItemCollapsibleState.Collapsed)
+      );
+    }
+    const incoming = graph.edges.filter(
+      (e) => e.target === element.id && e.attributes.type === "navigation"
+    );
+    const outgoing = graph.edges.filter(
+      (e) => e.source === element.id && e.attributes.type === "navigation"
+    );
+    return [
+      ...incoming.map((e) => {
+        const source = graph.nodes.find((n) => n.id === e.source);
+        return new RouteTreeItem(
+          `\u2190 ${source?.attributes.path ?? e.source}`,
+          e.source,
+          vscode.TreeItemCollapsibleState.None
+        );
+      }),
+      ...outgoing.map((e) => {
+        const target = graph.nodes.find((n) => n.id === e.target);
+        return new RouteTreeItem(
+          `\u2192 ${target?.attributes.path ?? e.target}`,
+          e.target,
+          vscode.TreeItemCollapsibleState.None
+        );
+      })
+    ];
+  }
+};
+var RouteTreeItem = class extends vscode.TreeItem {
+  constructor(label, id, collapsibleState) {
+    super(label, collapsibleState);
+    this.id = id;
+  }
+  id;
+};
+function activate(context) {
+  const treeProvider = new RouteTreeProvider();
+  vscode.window.registerTreeDataProvider("routeIntelligenceRoutes", treeProvider);
+  const hoverProvider = vscode.languages.registerHoverProvider(
+    ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    {
+      provideHover(document, position) {
+        if (!cachedGraph) return null;
+        const line = document.lineAt(position.line).text;
+        const hrefMatch = line.match(/href=["']([^"']+)["']/);
+        if (hrefMatch?.[1]) {
+          const path = hrefMatch[1];
+          const node = cachedGraph.nodes.find((n) => n.attributes.path === path);
+          if (node) {
+            return new vscode.Hover(
+              [
+                `**Route:** ${node.attributes.path}`,
+                `Type: ${node.attributes.type}`,
+                `File: ${node.attributes.filePath}`,
+                node.attributes.isDead ? "\u26A0 Dead route" : ""
+              ].filter(Boolean).join("\n\n")
+            );
+          }
+          return new vscode.Hover(`\u26A0 Unknown route: ${path}`);
+        }
+        return null;
+      }
+    }
+  );
+  const definitionProvider = vscode.languages.registerDefinitionProvider(
+    ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    {
+      provideDefinition(document, position) {
+        if (!cachedGraph) return null;
+        const line = document.lineAt(position.line).text;
+        const hrefMatch = line.match(/href=["']([^"']+)["']/);
+        if (!hrefMatch?.[1]) return null;
+        const node = cachedGraph.nodes.find((n) => n.attributes.path === hrefMatch[1]);
+        if (node) {
+          return new vscode.Location(
+            vscode.Uri.file(node.attributes.filePath),
+            new vscode.Position(0, 0)
+          );
+        }
+        return null;
+      }
+    }
+  );
+  context.subscriptions.push(
+    vscode.commands.registerCommand("route-intelligence.analyze", async () => {
+      await vscode.window.withProgress(
+        { location: vscode.ProgressLocation.Notification, title: "Analyzing routes..." },
+        async () => {
+          await analyzeWorkspace();
+          treeProvider.refresh();
+        }
+      );
+      vscode.window.showInformationMessage("Route analysis complete");
+    }),
+    vscode.commands.registerCommand("route-intelligence.showGraph", () => {
+      const panel = vscode.window.createWebviewPanel(
+        "routeGraph",
+        "Route Graph",
+        vscode.ViewColumn.One,
+        { enableScripts: true }
+      );
+      panel.webview.html = getWebviewContent();
+    }),
+    hoverProvider,
+    definitionProvider,
+    diagnosticCollection
+  );
+  void analyzeWorkspace().then(() => treeProvider.refresh());
+  vscode.workspace.onDidSaveTextDocument(async (doc) => {
+    if (/\.(tsx?|jsx?)$/.test(doc.fileName)) {
+      await analyzeWorkspace();
+      treeProvider.refresh();
+    }
+  });
+}
+function getWebviewContent() {
+  return "<!DOCTYPE html><html><body><h1>Route Graph</h1><p>Run route-intelligence graph for full visualization</p></body></html>";
+}
+function deactivate() {
+  diagnosticCollection.dispose();
+}
+export {
+  activate,
+  deactivate
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "route-intelligence-vscode",
+  "displayName": "Route Intelligence",
+  "description": "Routing intelligence for React and Next.js applications",
+  "version": "1.1.0",
+  "publisher": "route-intelligence",
+  "engines": {
+    "vscode": "^1.90.0"
+  },
+  "categories": ["Other", "Linters"],
+  "activationEvents": [
+    "onLanguage:typescript",
+    "onLanguage:typescriptreact",
+    "onLanguage:javascript",
+    "onLanguage:javascriptreact"
+  ],
+  "type": "module",
+  "main": "./dist/extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "route-intelligence.analyze",
+        "title": "Route Intelligence: Analyze Project"
+      },
+      {
+        "command": "route-intelligence.showGraph",
+        "title": "Route Intelligence: Show Route Graph"
+      }
+    ],
+    "views": {
+      "explorer": [
+        {
+          "id": "routeIntelligenceRoutes",
+          "name": "Route Intelligence"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsup src/extension.ts --format esm --dts --clean --external vscode",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@route-intelligence/core": "*",
+    "@route-intelligence/next": "*",
+    "@route-intelligence/shared": "*"
+  },
+  "devDependencies": {
+    "@route-intelligence/tsconfig": "*",
+    "@types/node": "^22.15.32",
+    "@types/vscode": "^1.90.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3"
+  },
+  "license": "MIT"
+}

package/src/extension.ts

@@ -0,0 +1,222 @@
+import { type RouteGraph, createAnalyzer, exportJson } from '@route-intelligence/core';
+import { NextPlugin } from '@route-intelligence/next';
+import type { SerializedGraph } from '@route-intelligence/shared';
+import * as vscode from 'vscode';
+
+let cachedGraph: SerializedGraph | null = null;
+const diagnosticCollection = vscode.languages.createDiagnosticCollection('route-intelligence');
+
+async function analyzeWorkspace(): Promise<SerializedGraph | null> {
+  const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+  if (!workspaceRoot) return null;
+
+  const analyzer = createAnalyzer({
+    root: workspaceRoot,
+    plugins: [NextPlugin()],
+    include: ['app/**', 'pages/**', 'src/**', 'middleware.ts'],
+    exclude: ['**/node_modules/**', '**/.next/**'],
+  });
+
+  const result = await analyzer.analyze();
+  cachedGraph = JSON.parse(
+    exportJson(result.graph as RouteGraph, workspaceRoot),
+  ) as SerializedGraph;
+
+  updateDiagnostics(result.diagnostics);
+  return cachedGraph;
+}
+
+function updateDiagnostics(
+  diagnostics: Array<{
+    severity: string;
+    message: string;
+    loc?: { filePath: string; line: number; column: number };
+  }>,
+) {
+  diagnosticCollection.clear();
+  const byFile = new Map<string, vscode.Diagnostic[]>();
+
+  for (const d of diagnostics) {
+    if (!d.loc?.filePath) continue;
+    const diags = byFile.get(d.loc.filePath) ?? [];
+    diags.push(
+      new vscode.Diagnostic(
+        new vscode.Range(
+          Math.max(0, d.loc.line - 1),
+          d.loc.column,
+          Math.max(0, d.loc.line - 1),
+          d.loc.column + 1,
+        ),
+        d.message,
+        d.severity === 'error'
+          ? vscode.DiagnosticSeverity.Error
+          : vscode.DiagnosticSeverity.Warning,
+      ),
+    );
+    byFile.set(d.loc.filePath, diags);
+  }
+
+  for (const [file, diags] of byFile) {
+    diagnosticCollection.set(vscode.Uri.file(file), diags);
+  }
+}
+
+class RouteTreeProvider implements vscode.TreeDataProvider<RouteTreeItem> {
+  private _onDidChangeTreeData = new vscode.EventEmitter<RouteTreeItem | undefined>();
+  readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+  refresh(): void {
+    this._onDidChangeTreeData.fire(undefined);
+  }
+
+  getTreeItem(element: RouteTreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  getChildren(element?: RouteTreeItem): RouteTreeItem[] {
+    if (!cachedGraph) return [];
+    const graph = cachedGraph;
+    if (!element) {
+      return graph.nodes
+        .filter((n) => n.attributes.type === 'route')
+        .map(
+          (n) =>
+            new RouteTreeItem(n.attributes.path, n.id, vscode.TreeItemCollapsibleState.Collapsed),
+        );
+    }
+
+    const incoming = graph.edges.filter(
+      (e) => e.target === element.id && e.attributes.type === 'navigation',
+    );
+    const outgoing = graph.edges.filter(
+      (e) => e.source === element.id && e.attributes.type === 'navigation',
+    );
+
+    return [
+      ...incoming.map((e) => {
+        const source = graph.nodes.find((n) => n.id === e.source);
+        return new RouteTreeItem(
+          `← ${source?.attributes.path ?? e.source}`,
+          e.source,
+          vscode.TreeItemCollapsibleState.None,
+        );
+      }),
+      ...outgoing.map((e) => {
+        const target = graph.nodes.find((n) => n.id === e.target);
+        return new RouteTreeItem(
+          `→ ${target?.attributes.path ?? e.target}`,
+          e.target,
+          vscode.TreeItemCollapsibleState.None,
+        );
+      }),
+    ];
+  }
+}
+
+class RouteTreeItem extends vscode.TreeItem {
+  constructor(
+    label: string,
+    public readonly id: string,
+    collapsibleState: vscode.TreeItemCollapsibleState,
+  ) {
+    super(label, collapsibleState);
+  }
+}
+
+export function activate(context: vscode.ExtensionContext) {
+  const treeProvider = new RouteTreeProvider();
+  vscode.window.registerTreeDataProvider('routeIntelligenceRoutes', treeProvider);
+
+  const hoverProvider = vscode.languages.registerHoverProvider(
+    ['typescript', 'typescriptreact', 'javascript', 'javascriptreact'],
+    {
+      provideHover(document, position) {
+        if (!cachedGraph) return null;
+        const line = document.lineAt(position.line).text;
+
+        const hrefMatch = line.match(/href=["']([^"']+)["']/);
+        if (hrefMatch?.[1]) {
+          const path = hrefMatch[1];
+          const node = cachedGraph.nodes.find((n) => n.attributes.path === path);
+          if (node) {
+            return new vscode.Hover(
+              [
+                `**Route:** ${node.attributes.path}`,
+                `Type: ${node.attributes.type}`,
+                `File: ${node.attributes.filePath}`,
+                node.attributes.isDead ? '⚠ Dead route' : '',
+              ]
+                .filter(Boolean)
+                .join('\n\n'),
+            );
+          }
+          return new vscode.Hover(`⚠ Unknown route: ${path}`);
+        }
+        return null;
+      },
+    },
+  );
+
+  const definitionProvider = vscode.languages.registerDefinitionProvider(
+    ['typescript', 'typescriptreact', 'javascript', 'javascriptreact'],
+    {
+      provideDefinition(document, position) {
+        if (!cachedGraph) return null;
+        const line = document.lineAt(position.line).text;
+        const hrefMatch = line.match(/href=["']([^"']+)["']/);
+        if (!hrefMatch?.[1]) return null;
+
+        const node = cachedGraph.nodes.find((n) => n.attributes.path === hrefMatch[1]);
+        if (node) {
+          return new vscode.Location(
+            vscode.Uri.file(node.attributes.filePath),
+            new vscode.Position(0, 0),
+          );
+        }
+        return null;
+      },
+    },
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('route-intelligence.analyze', async () => {
+      await vscode.window.withProgress(
+        { location: vscode.ProgressLocation.Notification, title: 'Analyzing routes...' },
+        async () => {
+          await analyzeWorkspace();
+          treeProvider.refresh();
+        },
+      );
+      vscode.window.showInformationMessage('Route analysis complete');
+    }),
+    vscode.commands.registerCommand('route-intelligence.showGraph', () => {
+      const panel = vscode.window.createWebviewPanel(
+        'routeGraph',
+        'Route Graph',
+        vscode.ViewColumn.One,
+        { enableScripts: true },
+      );
+      panel.webview.html = getWebviewContent();
+    }),
+    hoverProvider,
+    definitionProvider,
+    diagnosticCollection,
+  );
+
+  void analyzeWorkspace().then(() => treeProvider.refresh());
+
+  vscode.workspace.onDidSaveTextDocument(async (doc) => {
+    if (/\.(tsx?|jsx?)$/.test(doc.fileName)) {
+      await analyzeWorkspace();
+      treeProvider.refresh();
+    }
+  });
+}
+
+function getWebviewContent(): string {
+  return '<!DOCTYPE html><html><body><h1>Route Graph</h1><p>Run route-intelligence graph for full visualization</p></body></html>';
+}
+
+export function deactivate() {
+  diagnosticCollection.dispose();
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tooling/tsconfig/node.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
+  "include": ["src/**/*"]
+}