@eduardbar/drift 0.9.1 → 1.0.0

package/packages/vscode-drift/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "vscode-drift",
+  "displayName": "drift — Technical Debt Detector",
+  "description": "Detect technical debt in TypeScript & JavaScript. AST-based score 0–100: complexity, dead code, coupling, nesting and more.",
+  "version": "0.1.1",
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "publisher": "eduardbar",
+  "license": "MIT",
+  "icon": "images/icon.png",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eduardbar/drift"
+  },
+  "bugs": {
+    "url": "https://github.com/eduardbar/drift/issues"
+  },
+  "homepage": "https://github.com/eduardbar/drift#readme",
+  "qna": "https://github.com/eduardbar/drift/issues",
+  "categories": ["Linters", "Programming Languages"],
+  "keywords": [
+    "technical debt",
+    "debt",
+    "code quality",
+    "linter",
+    "typescript",
+    "javascript",
+    "complexity",
+    "dead code",
+    "coupling",
+    "nesting",
+    "score",
+    "refactor",
+    "analyzer",
+    "analysis",
+    "anti-patterns",
+    "ast",
+    "cyclomatic",
+    "any",
+    "console.log",
+    "catch",
+    "multi-root ready"
+  ],
+  "galleryBanner": {
+    "color": "#0a0a0f",
+    "theme": "dark"
+  },
+  "badges": [
+    {
+      "url": "https://img.shields.io/visual-studio-marketplace/v/eduardbar.vscode-drift?color=6366f1&label=version",
+      "href": "https://marketplace.visualstudio.com/items?itemName=eduardbar.vscode-drift",
+      "description": "Marketplace Version"
+    },
+    {
+      "url": "https://img.shields.io/visual-studio-marketplace/i/eduardbar.vscode-drift?color=8b5cf6&label=installs",
+      "href": "https://marketplace.visualstudio.com/items?itemName=eduardbar.vscode-drift",
+      "description": "Installs"
+    }
+  ],
+  "activationEvents": [
+    "onLanguage:typescript",
+    "onLanguage:typescriptreact",
+    "onLanguage:javascript",
+    "onLanguage:javascriptreact"
+  ],
+  "main": "./dist/extension.js",
+  "contributes": {
+    "views": {
+      "explorer": [
+        {
+          "id": "driftIssues",
+          "name": "Drift Issues",
+          "when": "workspaceFolderCount > 0"
+        }
+      ]
+    },
+    "commands": [
+      {
+        "command": "drift.scanWorkspace",
+        "title": "Drift: Scan Workspace"
+      },
+      {
+        "command": "drift.clearDiagnostics",
+        "title": "Drift: Clear Diagnostics"
+      }
+    ],
+    "configuration": {
+      "title": "Drift",
+      "properties": {
+        "drift.enable": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable drift analysis on save"
+        },
+        "drift.minSeverity": {
+          "type": "string",
+          "enum": ["error", "warning", "info"],
+          "default": "info",
+          "description": "Minimum severity level to show"
+        }
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "watch": "tsc -p tsconfig.json --watch",
+    "vscode:prepublish": "npm run build"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.85.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  },
+  "dependencies": {
+    "@eduardbar/drift": "*",
+    "ts-morph": "^23.0.0"
+  }
+}

package/packages/vscode-drift/src/analyzer.ts

@@ -0,0 +1,38 @@
+import { Project } from 'ts-morph'
+import type { FileReport } from '@eduardbar/drift'
+
+// Import dinámico para compatibilidad CommonJS -> ESM
+// @eduardbar/drift es "type": "module" pero desde CommonJS
+// se debe usar import() dinámico.
+// _analyzeFile se tipea como `Function` para evitar el conflicto de
+// instancias duplicadas de ts-morph (una en este paquete, otra en
+// @eduardbar/drift/node_modules). En runtime son compatibles.
+// eslint-disable-next-line @typescript-eslint/ban-types
+let _analyzeFile: Function | null = null
+
+async function getAnalyzeFile(): Promise<Function> {
+  if (!_analyzeFile) {
+    // drift es ES module, desde CommonJS usamos import() dinámico
+    const drift = await import('@eduardbar/drift')
+    _analyzeFile = drift.analyzeFile
+  }
+  return _analyzeFile!
+}
+
+export async function analyzeFilePath(filePath: string): Promise<FileReport | null> {
+  try {
+    const analyzeFile = await getAnalyzeFile()
+    const project = new Project({
+      compilerOptions: {
+        allowJs: true,
+        jsx: 1, // JsxEmit.Preserve
+      },
+      skipAddingFilesFromTsConfig: true,
+    })
+    const sourceFile = project.addSourceFileAtPath(filePath)
+    return analyzeFile(sourceFile) as FileReport
+  } catch (err) {
+    console.error('[drift] analyzeFilePath error:', err)
+    return null
+  }
+}

package/packages/vscode-drift/src/diagnostics.ts

@@ -0,0 +1,55 @@
+import * as vscode from 'vscode'
+import type { FileReport } from '@eduardbar/drift'
+
+const SEVERITY_MAP: Record<string, vscode.DiagnosticSeverity> = {
+  error: vscode.DiagnosticSeverity.Error,
+  warning: vscode.DiagnosticSeverity.Warning,
+  info: vscode.DiagnosticSeverity.Information,
+}
+
+export class DriftDiagnosticsProvider {
+  private collection: vscode.DiagnosticCollection
+
+  constructor() {
+    this.collection = vscode.languages.createDiagnosticCollection('drift')
+  }
+
+  update(report: FileReport): void {
+    const uri = vscode.Uri.file(report.path)
+    const config = vscode.workspace.getConfiguration('drift')
+    const minSeverity = config.get<string>('minSeverity', 'info')
+
+    const severityOrder = ['error', 'warning', 'info']
+    const minIdx = severityOrder.indexOf(minSeverity)
+
+    const diagnostics: vscode.Diagnostic[] = report.issues
+      .filter(issue => severityOrder.indexOf(issue.severity) <= minIdx)
+      .map(issue => {
+        // line es 1-based en drift, VS Code usa 0-based
+        const line = Math.max(0, issue.line - 1)
+        const range = new vscode.Range(line, 0, line, Number.MAX_SAFE_INTEGER)
+        const diagnostic = new vscode.Diagnostic(
+          range,
+          `[drift/${issue.rule}] ${issue.message}`,
+          SEVERITY_MAP[issue.severity] ?? vscode.DiagnosticSeverity.Information
+        )
+        diagnostic.source = 'drift'
+        diagnostic.code = issue.rule
+        return diagnostic
+      })
+
+    this.collection.set(uri, diagnostics)
+  }
+
+  clear(uri?: vscode.Uri): void {
+    if (uri) {
+      this.collection.delete(uri)
+    } else {
+      this.collection.clear()
+    }
+  }
+
+  dispose(): void {
+    this.collection.dispose()
+  }
+}

package/packages/vscode-drift/src/extension.ts

@@ -0,0 +1,111 @@
+import * as vscode from 'vscode'
+import { analyzeFilePath } from './analyzer'
+import { DriftDiagnosticsProvider } from './diagnostics'
+import { DriftTreeProvider } from './treeview'
+import { DriftStatusBarItem } from './statusbar'
+import type { FileReport } from '@eduardbar/drift'
+
+const SUPPORTED_LANGUAGES = ['typescript', 'typescriptreact', 'javascript', 'javascriptreact']
+
+export function activate(context: vscode.ExtensionContext): void {
+  const diagnostics = new DriftDiagnosticsProvider()
+  const treeProvider = new DriftTreeProvider()
+  const statusBar = new DriftStatusBarItem()
+
+  // Registrar TreeView
+  const treeView = vscode.window.createTreeView('driftIssues', {
+    treeDataProvider: treeProvider,
+    showCollapseAll: true,
+  })
+
+  // Cache de reports para la status bar
+  const reportCache = new Map<string, FileReport>()
+
+  async function analyzeAndUpdate(document: vscode.TextDocument): Promise<void> {
+    const config = vscode.workspace.getConfiguration('drift')
+    if (!config.get<boolean>('enable', true)) return
+
+    if (!SUPPORTED_LANGUAGES.includes(document.languageId)) return
+    if (document.uri.scheme !== 'file') return
+
+    const filePath = document.uri.fsPath
+
+    const report = await analyzeFilePath(filePath)
+    if (!report) return
+
+    diagnostics.update(report)
+    treeProvider.updateFile(report)
+    reportCache.set(filePath, report)
+    statusBar.update(Array.from(reportCache.values()))
+  }
+
+  // Trigger: al guardar
+  const onSave = vscode.workspace.onDidSaveTextDocument(analyzeAndUpdate)
+
+  // Comando: scan workspace
+  const scanCmd = vscode.commands.registerCommand('drift.scanWorkspace', async () => {
+    const files = await vscode.workspace.findFiles(
+      '**/*.{ts,tsx,js,jsx}',
+      '**/node_modules/**'
+    )
+
+    vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: 'drift: Scanning workspace...',
+        cancellable: false,
+      },
+      async (progress) => {
+        const total = files.length
+        let done = 0
+
+        for (const file of files) {
+          const report = await analyzeFilePath(file.fsPath)
+          if (report) {
+            diagnostics.update(report)
+            treeProvider.updateFile(report)
+            reportCache.set(file.fsPath, report)
+          }
+          done++
+          progress.report({ increment: (done / total) * 100 })
+        }
+
+        statusBar.update(Array.from(reportCache.values()))
+        vscode.window.showInformationMessage(`drift: ${total} files scanned.`)
+      }
+    )
+  })
+
+  // Comando: clear
+  const clearCmd = vscode.commands.registerCommand('drift.clearDiagnostics', () => {
+    diagnostics.clear()
+    treeProvider.clearAll()
+    reportCache.clear()
+    statusBar.update([])
+  })
+
+  // Comando: go to issue (desde TreeView click)
+  const goToCmd = vscode.commands.registerCommand(
+    'drift.goToIssue',
+    async (filePath: string, line: number) => {
+      const uri = vscode.Uri.file(filePath)
+      const doc = await vscode.workspace.openTextDocument(uri)
+      const editor = await vscode.window.showTextDocument(doc)
+      const pos = new vscode.Position(Math.max(0, line - 1), 0)
+      editor.selection = new vscode.Selection(pos, pos)
+      editor.revealRange(new vscode.Range(pos, pos), vscode.TextEditorRevealType.InCenter)
+    }
+  )
+
+  context.subscriptions.push(
+    { dispose: () => diagnostics.dispose() },
+    { dispose: () => statusBar.dispose() },
+    treeView,
+    onSave,
+    scanCmd,
+    clearCmd,
+    goToCmd,
+  )
+}
+
+export function deactivate(): void {}

package/packages/vscode-drift/src/statusbar.ts

@@ -0,0 +1,47 @@
+import * as vscode from 'vscode'
+import type { FileReport } from '@eduardbar/drift'
+
+export class DriftStatusBarItem {
+  private item: vscode.StatusBarItem
+
+  constructor() {
+    this.item = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Right,
+      100
+    )
+    this.item.command = 'drift.scanWorkspace'
+    this.item.tooltip = 'Click to scan workspace'
+  }
+
+  update(reports: FileReport[]): void {
+    if (reports.length === 0) {
+      this.item.text = '$(check) drift'
+      this.item.backgroundColor = undefined
+      this.item.show()
+      return
+    }
+
+    const totalScore = Math.round(
+      reports.reduce((sum, r) => sum + r.score, 0) / reports.length
+    )
+    const totalIssues = reports.reduce((sum, r) => sum + r.issues.length, 0)
+    const hasErrors = reports.some(r => r.issues.some(i => i.severity === 'error'))
+
+    const icon = hasErrors ? '$(error)' : totalScore < 50 ? '$(warning)' : '$(check)'
+    this.item.text = `${icon} drift ${totalScore}/100 · ${totalIssues} issues`
+
+    if (hasErrors || totalScore < 30) {
+      this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.errorBackground')
+    } else if (totalScore < 60) {
+      this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground')
+    } else {
+      this.item.backgroundColor = undefined
+    }
+
+    this.item.show()
+  }
+
+  dispose(): void {
+    this.item.dispose()
+  }
+}

package/packages/vscode-drift/src/treeview.ts

@@ -0,0 +1,108 @@
+import * as vscode from 'vscode'
+import * as path from 'path'
+import type { FileReport } from '@eduardbar/drift'
+
+type TreeItemType = 'file' | 'issue'
+
+export class DriftTreeItem extends vscode.TreeItem {
+  constructor(
+    public readonly label: string,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+    public readonly itemType: TreeItemType,
+    public readonly fileReport?: FileReport,
+    public readonly issueIndex?: number
+  ) {
+    super(label, collapsibleState)
+
+    if (itemType === 'file' && fileReport) {
+      const score = fileReport.score
+      const issueCount = fileReport.issues.length
+      this.description = `score: ${score}  •  ${issueCount} issue${issueCount !== 1 ? 's' : ''}`
+      this.tooltip = fileReport.path
+      this.iconPath = score >= 70
+        ? new vscode.ThemeIcon('check', new vscode.ThemeColor('testing.iconPassed'))
+        : score >= 40
+        ? new vscode.ThemeIcon('warning', new vscode.ThemeColor('problemsWarningIcon.foreground'))
+        : new vscode.ThemeIcon('error', new vscode.ThemeColor('problemsErrorIcon.foreground'))
+      this.contextValue = 'driftFile'
+    }
+
+    if (itemType === 'issue' && fileReport && issueIndex !== undefined) {
+      const issue = fileReport.issues[issueIndex]
+      this.description = `line ${issue.line}`
+      this.tooltip = issue.message
+      this.iconPath = issue.severity === 'error'
+        ? new vscode.ThemeIcon('circle-filled', new vscode.ThemeColor('problemsErrorIcon.foreground'))
+        : issue.severity === 'warning'
+        ? new vscode.ThemeIcon('warning', new vscode.ThemeColor('problemsWarningIcon.foreground'))
+        : new vscode.ThemeIcon('info', new vscode.ThemeColor('problemsInfoIcon.foreground'))
+
+      // Click para ir a la línea
+      this.command = {
+        command: 'drift.goToIssue',
+        title: 'Go to Issue',
+        arguments: [fileReport.path, issue.line],
+      }
+      this.contextValue = 'driftIssue'
+    }
+  }
+}
+
+export class DriftTreeProvider implements vscode.TreeDataProvider<DriftTreeItem> {
+  private _onDidChangeTreeData = new vscode.EventEmitter<DriftTreeItem | undefined | null | void>()
+  readonly onDidChangeTreeData = this._onDidChangeTreeData.event
+
+  private reports = new Map<string, FileReport>()
+
+  refresh(): void {
+    this._onDidChangeTreeData.fire()
+  }
+
+  updateFile(report: FileReport): void {
+    this.reports.set(report.path, report)
+    this.refresh()
+  }
+
+  clearFile(filePath: string): void {
+    this.reports.delete(filePath)
+    this.refresh()
+  }
+
+  clearAll(): void {
+    this.reports.clear()
+    this.refresh()
+  }
+
+  getTreeItem(element: DriftTreeItem): vscode.TreeItem {
+    return element
+  }
+
+  getChildren(element?: DriftTreeItem): DriftTreeItem[] {
+    if (!element) {
+      // Root: lista de archivos con issues, ordenados por score ascendente
+      return Array.from(this.reports.values())
+        .filter(r => r.issues.length > 0)
+        .sort((a, b) => a.score - b.score)
+        .map(r => new DriftTreeItem(
+          path.basename(r.path),
+          vscode.TreeItemCollapsibleState.Collapsed,
+          'file',
+          r
+        ))
+    }
+
+    if (element.itemType === 'file' && element.fileReport) {
+      return element.fileReport.issues.map((_, i) =>
+        new DriftTreeItem(
+          element.fileReport!.issues[i].rule,
+          vscode.TreeItemCollapsibleState.None,
+          'issue',
+          element.fileReport,
+          i
+        )
+      )
+    }
+
+    return []
+  }
+}

package/packages/vscode-drift/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}