@eduardbar/drift 0.9.1 → 1.1.0

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,135 @@
+// drift-ignore-file
+
+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']
+
+async function analyzeAndUpdate(
+  document: vscode.TextDocument,
+  diagnostics: DriftDiagnosticsProvider,
+  treeProvider: DriftTreeProvider,
+  reportCache: Map<string, FileReport>,
+  statusBar: DriftStatusBarItem
+): 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()))
+}
+
+async function scanWorkspace(
+  diagnostics: DriftDiagnosticsProvider,
+  treeProvider: DriftTreeProvider,
+  reportCache: Map<string, FileReport>,
+  statusBar: DriftStatusBarItem
+): Promise<void> {
+  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.`)
+    }
+  )
+}
+
+function clearDiagnostics(
+  diagnostics: DriftDiagnosticsProvider,
+  treeProvider: DriftTreeProvider,
+  reportCache: Map<string, FileReport>,
+  statusBar: DriftStatusBarItem
+): void {
+  diagnostics.clear()
+  treeProvider.clearAll()
+  reportCache.clear()
+  statusBar.update([])
+}
+
+export function activate(context: vscode.ExtensionContext): void {
+  const diagnostics = new DriftDiagnosticsProvider()
+  const treeProvider = new DriftTreeProvider()
+  const statusBar = new DriftStatusBarItem()
+
+  const treeView = vscode.window.createTreeView('driftIssues', {
+    treeDataProvider: treeProvider,
+    showCollapseAll: true,
+  })
+
+  const reportCache = new Map<string, FileReport>()
+
+  const onSave = vscode.workspace.onDidSaveTextDocument(
+    (doc) => analyzeAndUpdate(doc, diagnostics, treeProvider, reportCache, statusBar)
+  )
+
+  const scanCmd = vscode.commands.registerCommand(
+    'drift.scanWorkspace',
+    () => scanWorkspace(diagnostics, treeProvider, reportCache, statusBar)
+  )
+
+  const clearCmd = vscode.commands.registerCommand(
+    'drift.clearDiagnostics',
+    () => clearDiagnostics(diagnostics, treeProvider, reportCache, statusBar)
+  )
+
+  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,55 @@
+import * as vscode from 'vscode'
+import type { FileReport } from '@eduardbar/drift'
+
+const STATUSBAR_PRIORITY = 100
+
+const SCORE_THRESHOLDS = {
+  WARNING: 50,
+  ERROR: 30,
+  WARNING_BG: 60,
+}
+
+export class DriftStatusBarItem {
+  private item: vscode.StatusBarItem
+
+  constructor() {
+    this.item = vscode.createStatusBarItem(
+      vscode.StatusBarAlignment.Right,
+      STATUSBAR_PRIORITY
+    )
+    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 < SCORE_THRESHOLDS.WARNING ? '$(warning)' : '$(check)'
+    this.item.text = `${icon} drift ${totalScore}/100 · ${totalIssues} issues`
+
+    if (hasErrors || totalScore < SCORE_THRESHOLDS.ERROR) {
+      this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.errorBackground')
+    } else if (totalScore < SCORE_THRESHOLDS.WARNING_BG) {
+      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,110 @@
+// drift-ignore-file
+
+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"]
+}