@pellux/goodvibes-agent 0.1.59 → 0.1.60

package/src/panels/intelligence-panel.ts

@@ -1,176 +0,0 @@
-import type { Line } from '../types/grid.ts';
-import { createEmptyLine } from '../types/grid.ts';
-import { BasePanel } from './base-panel.ts';
-import type { UiIntelligenceSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
-import {
-  buildEmptyState,
-  buildGuidanceLine,
-  buildKeyValueLine,
-  buildPanelLine,
-  buildPanelWorkspace,
-  DEFAULT_PANEL_PALETTE,
-  type PanelWorkspaceSection,
-} from './polish.ts';
-
-const C = {
-  ...DEFAULT_PANEL_PALETTE,
-  good: '#22c55e',
-  warn: '#f59e0b',
-  bad: '#ef4444',
-  info: '#38bdf8',
-  headerBg: '#1e293b',
-} as const;
-
-function statusColor(status: string): string {
-  switch (status) {
-    case 'ready':
-      return C.good;
-    case 'loading':
-      return C.info;
-    case 'degraded':
-      return C.warn;
-    case 'unavailable':
-    default:
-      return C.bad;
-  }
-}
-
-export class IntelligencePanel extends BasePanel {
-  private readonly unsub: (() => void) | null;
-
-  public constructor(private readonly readModel?: UiReadModel<UiIntelligenceSnapshot>) {
-    super('intelligence', 'Intelligence', 'J', 'development');
-    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
-  }
-
-  public override onDestroy(): void {
-    this.unsub?.();
-  }
-
-  public render(width: number, height: number): Line[] {
-    this.needsRender = false;
-    if (!this.readModel) {
-      const lines = buildPanelWorkspace(width, height, {
-        title: 'Intelligence Control Room',
-        intro: 'Workspace intelligence posture across diagnostics, symbols, completions, and hover readiness.',
-        sections: [{
-          lines: buildEmptyState(
-            width,
-            ' Intelligence runtime store unavailable.',
-            'This surface needs the live runtime store so it can show diagnostics, symbol readiness, and recovery guidance.',
-            [{ command: '/intelligence review', summary: 'review intelligence readiness from the command surface' }],
-            C,
-          ),
-        }],
-        palette: C,
-      });
-      while (lines.length < height) lines.push(createEmptyLine(width));
-      return lines.slice(0, height);
-    }
-
-    const state = this.readModel.getSnapshot();
-    const degraded = [
-      state.diagnosticsStatus,
-      state.completionsStatus,
-      state.symbolSearchStatus,
-      state.hoverStatus,
-    ].filter((status) => status !== 'ready').length;
-
-    const sections: PanelWorkspaceSection[] = [
-      {
-        title: 'Intelligence posture',
-        lines: [
-          buildKeyValueLine(width, [
-            { label: 'diagnostics', value: state.diagnosticsStatus, valueColor: statusColor(state.diagnosticsStatus) },
-            { label: 'symbols', value: state.symbolSearchStatus, valueColor: statusColor(state.symbolSearchStatus) },
-            { label: 'completions', value: state.completionsStatus, valueColor: statusColor(state.completionsStatus) },
-            { label: 'hover', value: state.hoverStatus, valueColor: statusColor(state.hoverStatus) },
-          ], C),
-          buildKeyValueLine(width, [
-            { label: 'errors', value: String(state.errorCount), valueColor: state.errorCount > 0 ? C.bad : C.dim },
-            { label: 'warnings', value: String(state.warningCount), valueColor: state.warningCount > 0 ? C.warn : C.dim },
-            { label: 'requests', value: String(state.totalRequests), valueColor: C.value },
-            { label: 'avg latency', value: `${Math.round(state.avgLatencyMs)}ms`, valueColor: C.info },
-          ], C),
-        ],
-      },
-      {
-        title: 'Next Actions',
-        lines: [
-          buildGuidanceLine(width, '/intelligence diagnostics', 'review readiness posture and current diagnostics activity', C),
-          buildGuidanceLine(width, '/intelligence repair', 'surface repair-oriented guidance when symbols, hover, or completions degrade', C),
-        ],
-      },
-      {
-        title: 'Readiness',
-        lines: [
-          buildPanelLine(width, [[` Diagnostics are ${state.diagnosticsStatus}. Symbol search is ${state.symbolSearchStatus}.`, state.diagnosticsStatus === 'ready' && state.symbolSearchStatus === 'ready' ? C.dim : C.warn]]),
-          buildPanelLine(width, [[` Hover is ${state.hoverStatus}. Completions are ${state.completionsStatus}.`, state.hoverStatus === 'ready' && state.completionsStatus === 'ready' ? C.dim : C.warn]]),
-          ...(state.hover.active && state.hover.filePath
-            ? [buildPanelLine(width, [[` Active hover: ${state.hover.filePath}`, C.info]])]
-            : []),
-        ],
-      },
-    ];
-
-    const diagnosticFiles = [...state.diagnostics.entries()]
-      .map(([filePath, diagnostics]) => ({
-        filePath,
-        errors: diagnostics.filter((entry) => entry.severity === 'error').length,
-        warnings: diagnostics.filter((entry) => entry.severity === 'warning').length,
-      }))
-      .sort((a, b) => (b.errors - a.errors) || (b.warnings - a.warnings) || a.filePath.localeCompare(b.filePath))
-      .slice(0, 4);
-    sections.push({
-      title: 'Diagnostics',
-      lines: diagnosticFiles.length > 0
-        ? diagnosticFiles.map((entry) => buildPanelLine(width, [[
-            ` ${entry.filePath}  errors=${entry.errors} warnings=${entry.warnings}`,
-            entry.errors > 0 ? C.bad : entry.warnings > 0 ? C.warn : C.dim,
-          ]]))
-        : [buildPanelLine(width, [[' No tracked diagnostics yet.', C.dim]])],
-    });
-
-    sections.push({
-      title: 'Workflows',
-      lines: [
-        buildGuidanceLine(width, '/intelligence symbols <file>', 'inspect document symbols for a file and verify symbol-surface readiness', C),
-        buildGuidanceLine(width, '/intelligence outline <file>', 'review structural outline extraction without leaving the control room', C),
-        buildGuidanceLine(width, '/intelligence definition <file> <line> <column>', 'check definition lookup for an exact source position', C),
-        buildGuidanceLine(width, '/intelligence references <file> <line> <column>', 'review reference lookup for a symbol under the cursor', C),
-        buildGuidanceLine(width, '/intelligence hover <file> <line> <column>', 'inspect hover/details posture for a specific source position', C),
-      ],
-    });
-
-    if (degraded > 0) {
-      sections.push({
-        title: 'Recovery',
-        lines: [
-          buildPanelLine(width, [[' Workspace intelligence is not fully ready. Review LSP/tree-sitter setup and workspace language configuration.', C.warn]]),
-          buildGuidanceLine(width, '/health review', 'check setup and readiness failures that could block diagnostics and symbol search', C),
-          buildGuidanceLine(width, '/setup review', 'review startup and environment posture for intelligence dependencies', C),
-          buildGuidanceLine(width, '/intelligence repair', 'show repair-oriented commands for diagnostics, symbols, hover, and completions', C),
-          buildGuidanceLine(width, '/health repair intelligence', 'show repair commands plus post-repair verification for the intelligence domain', C),
-        ],
-      });
-    } else {
-      sections.push({
-        title: 'Recovery',
-        lines: [
-          buildPanelLine(width, [[' Intelligence surfaces are healthy and ready for code-aware workflows.', C.dim]]),
-          buildGuidanceLine(width, '/health intelligence', 'verify readiness posture after setup changes or dependency recovery', C),
-        ],
-      });
-    }
-
-    const lines = buildPanelWorkspace(width, height, {
-      title: 'Intelligence Control Room',
-      intro: 'Workspace intelligence posture across diagnostics, symbol search, hover, and completion readiness.',
-      sections,
-      footerLines: [buildPanelLine(width, [[' /symbols  /intelligence diagnostics  /intelligence symbols <file>  /intelligence definition <file> <line> <column> ', C.dim]])],
-      palette: C,
-    });
-    while (lines.length < height) lines.push(createEmptyLine(width));
-    return lines.slice(0, height);
-  }
-}

package/src/renderer/semantic-diff.ts

@@ -1,369 +0,0 @@
-/**
- * semantic-diff.ts — Functional change summary after file edits.
- *
- * Compares AST before/after an edit and extracts:
- *   - Added / removed / modified functions, methods, classes, etc.
- *   - Changed import specifiers
- *   - New / removed exports
- *
- * Returns a compact SemanticDiff that can be rendered alongside a regular diff.
- * Gracefully returns null when tree-sitter is unavailable or the language is
- * unsupported — callers should treat null as "no semantic info available".
- */
-
-import { TreeSitterService } from '@pellux/goodvibes-sdk/platform/intelligence';
-import { extractSymbols } from '@pellux/goodvibes-sdk/platform/intelligence';
-import type { SymbolInfo } from '@pellux/goodvibes-sdk/platform/intelligence';
-import { detectLanguage } from '@pellux/goodvibes-sdk/platform/intelligence';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-export type ChangeKind = 'added' | 'removed' | 'modified';
-
-export interface SymbolChange {
-  kind: ChangeKind;
-  symbolKind: SymbolInfo['kind'];
-  name: string;
-  /** Present for 'modified' — the old signature. */
-  oldSignature?: string;
-  /** Present for 'added' or 'modified' — the new signature. */
-  newSignature?: string;
-}
-
-export interface ImportChange {
-  kind: ChangeKind;
-  specifier: string; // the module path, e.g. './utils'
-  /** Specific named imports that changed, if determinable. */
-  names?: string[];
-}
-
-export interface SemanticDiff {
-  symbols: SymbolChange[];
-  imports: ImportChange[];
-  /** Convenience: total number of changes across all categories. */
-  totalChanges: number;
-}
-
-// ---------------------------------------------------------------------------
-// Import extraction (regex-based — fast, no grammar needed)
-// ---------------------------------------------------------------------------
-
-interface ParsedImport {
-  specifier: string;
-  names: string[];
-}
-
-/**
- * Extract import specifiers and named imports from source text using a regex
- * scan. Covers `import ... from '...'` and `import('...')` dynamic imports.
- * Does not require tree-sitter.
- */
-function extractImports(source: string): Map<string, ParsedImport> {
-  const map = new Map<string, ParsedImport>();
-
-  // Static imports: import { A, B } from './foo'
-  //                 import Foo from './foo'
-  //                 import * as Foo from './foo'
-  //                 import './side-effect'
-  const staticRe = /import\s+(?:([\s\S]*?)\s+from\s+)?['"]([^'"]+)['"]/g;
-  let m: RegExpExecArray | null;
-
-  while ((m = staticRe.exec(source)) !== null) {
-    const clause = (m[1] ?? '').trim();
-    const specifier = m[2]!;
-    const names = parseNamedImports(clause);
-    const existing = map.get(specifier);
-    if (existing) {
-      for (const n of names) existing.names.push(n);
-    } else {
-      map.set(specifier, { specifier, names });
-    }
-  }
-
-  return map;
-}
-
-/** Parse `{ A, B as C }` or `* as Ns` or `Default` clauses into name strings. */
-function parseNamedImports(clause: string): string[] {
-  if (!clause) return [];
-  // Namespace import: * as Foo
-  if (clause.startsWith('*')) return [clause];
-  // Named imports: { A, B as C }
-  const braceMatch = clause.match(/\{([^}]*)\}/);
-  if (braceMatch) {
-    return braceMatch[1]!
-      .split(',')
-      .map(s => s.trim())
-      .filter(Boolean);
-  }
-  // Default import: Foo
-  return clause ? [clause] : [];
-}
-
-// ---------------------------------------------------------------------------
-// Symbol comparison
-// ---------------------------------------------------------------------------
-
-function diffSymbols(
-  before: SymbolInfo[],
-  after: SymbolInfo[],
-): SymbolChange[] {
-  const changes: SymbolChange[] = [];
-
-  // Key by qualified name (container.name or name)
-  const key = (s: SymbolInfo): string =>
-    s.container ? `${s.container}.${s.name}` : s.name;
-
-  const beforeMap = new Map<string, SymbolInfo>();
-  const afterMap = new Map<string, SymbolInfo>();
-
-  for (const s of before) beforeMap.set(key(s), s);
-  for (const s of after) afterMap.set(key(s), s);
-
-  // Removed or modified
-  for (const [k, bSym] of beforeMap) {
-    const aSym = afterMap.get(k);
-    if (!aSym) {
-      changes.push({
-        kind: 'removed',
-        symbolKind: bSym.kind,
-        name: k,
-        oldSignature: bSym.signature,
-      });
-    } else if (
-      bSym.signature !== aSym.signature ||
-      bSym.exported !== aSym.exported
-    ) {
-      changes.push({
-        kind: 'modified',
-        symbolKind: aSym.kind,
-        name: k,
-        oldSignature: bSym.signature,
-        newSignature: aSym.signature,
-      });
-    }
-  }
-
-  // Added
-  for (const [k, aSym] of afterMap) {
-    if (!beforeMap.has(k)) {
-      changes.push({
-        kind: 'added',
-        symbolKind: aSym.kind,
-        name: k,
-        newSignature: aSym.signature,
-      });
-    }
-  }
-
-  return changes;
-}
-
-// ---------------------------------------------------------------------------
-// Import comparison
-// ---------------------------------------------------------------------------
-
-function diffImports(
-  before: Map<string, ParsedImport>,
-  after: Map<string, ParsedImport>,
-): ImportChange[] {
-  const changes: ImportChange[] = [];
-
-  // Removed or modified
-  for (const [spec, bImp] of before) {
-    const aImp = after.get(spec);
-    if (!aImp) {
-      changes.push({ kind: 'removed', specifier: spec, names: bImp.names });
-    } else {
-      // Check if named imports changed
-      const bSet = new Set(bImp.names);
-      const aSet = new Set(aImp.names);
-      const added = aImp.names.filter(n => !bSet.has(n));
-      const removed = bImp.names.filter(n => !aSet.has(n));
-      if (added.length > 0 || removed.length > 0) {
-        const names: string[] = [
-          ...added.map(n => `+${n}`),
-          ...removed.map(n => `-${n}`),
-        ];
-        changes.push({ kind: 'modified', specifier: spec, names });
-      }
-    }
-  }
-
-  // Added
-  for (const [spec, aImp] of after) {
-    if (!before.has(spec)) {
-      changes.push({ kind: 'added', specifier: spec, names: aImp.names });
-    }
-  }
-
-  return changes;
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Compare `beforeContent` and `afterContent` for the given `filePath` and
- * return a SemanticDiff describing functional changes.
- *
- * Returns null when:
- *   - The language is not supported by tree-sitter
- *   - Tree-sitter is not initialized
- *   - Parsing fails
- *
- * Import changes are always returned (regex-based, no grammar required).
- */
-export async function computeSemanticDiff(
-  filePath: string,
-  beforeContent: string,
-  afterContent: string,
-): Promise<SemanticDiff | null> {
-  // Import diff is always available (regex-based)
-  const beforeImports = extractImports(beforeContent);
-  const afterImports = extractImports(afterContent);
-  const imports = diffImports(beforeImports, afterImports);
-
-  const langId = detectLanguage(filePath);
-  if (!langId) {
-    // No language support — return import changes only if any
-    if (imports.length === 0) return null;
-    return { symbols: [], imports, totalChanges: imports.length };
-  }
-
-  const svc = new TreeSitterService();
-
-  try {
-    await svc.initialize();
-  } catch {
-    logger.debug('computeSemanticDiff: tree-sitter init failed', { filePath });
-    if (imports.length === 0) return null;
-    return { symbols: [], imports, totalChanges: imports.length };
-  }
-
-  // Use a temporary key so we don't pollute the service cache with diff content.
-  // Include a nonce so concurrent calls for the same filePath don't collide.
-  const nonce = Math.random().toString(36).slice(2);
-  const beforeKey = `__semantic_diff_before__${nonce}_${filePath}`;
-  const afterKey = `__semantic_diff_after__${nonce}_${filePath}`;
-
-  try {
-    const [beforeTree, afterTree] = await Promise.all([
-      svc.parse(beforeKey, beforeContent, langId),
-      svc.parse(afterKey, afterContent, langId),
-    ]);
-
-    if (!beforeTree || !afterTree) {
-      if (imports.length === 0) return null;
-      return { symbols: [], imports, totalChanges: imports.length };
-    }
-
-    // loadLanguage returns from cache since parse() already loaded it
-    const lang = await svc.loadLanguage(langId);
-    if (!lang) {
-      if (imports.length === 0) return null;
-      return { symbols: [], imports, totalChanges: imports.length };
-    }
-
-    const beforeSymbols = extractSymbols(beforeTree, lang, langId);
-    const afterSymbols = extractSymbols(afterTree, lang, langId);
-    const symbols = diffSymbols(beforeSymbols, afterSymbols);
-
-    // Clean up temporary cache entries
-    svc.invalidate(beforeKey);
-    svc.invalidate(afterKey);
-
-    const totalChanges = symbols.length + imports.length;
-    if (totalChanges === 0) return null;
-
-    return { symbols, imports, totalChanges };
-  } catch (err) {
-    logger.error('computeSemanticDiff: comparison failed', {
-      filePath,
-      error: summarizeError(err),
-    });
-    svc.invalidate(beforeKey);
-    svc.invalidate(afterKey);
-    if (imports.length === 0) return null;
-    return { symbols: [], imports, totalChanges: imports.length };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Display formatting
-// ---------------------------------------------------------------------------
-
-const KIND_ICON: Record<SymbolInfo['kind'], string> = {
-  function:  'fn',
-  method:    'method',
-  class:     'class',
-  interface: 'iface',
-  type:      'type',
-  variable:  'var',
-  constant:  'const',
-  enum:      'enum',
-  property:  'prop',
-  namespace: 'ns',
-};
-
-const CHANGE_GLYPH: Record<ChangeKind, string> = {
-  added:    '+',
-  removed:  '-',
-  modified: '~',
-};
-
-/**
- * Render a SemanticDiff as an array of compact summary strings, one change
- * per line. Suitable for display in the diff panel status area or a tooltip.
- *
- * Format examples:
- *   +  fn  renderDiffView
- *   ~  method  renderSummary  (signature changed)
- *   -  class  OldWidget
- *   +  import  ./utils  { A, B }
- *   ~  import  ./types  (+NewType, -OldType)
- */
-export function formatSemanticDiff(diff: SemanticDiff): string[] {
-  const lines: string[] = [];
-
-  // Symbol changes first
-  for (const sc of diff.symbols) {
-    const glyph = CHANGE_GLYPH[sc.kind];
-    const icon = KIND_ICON[sc.symbolKind];
-    let line = `${glyph}  ${icon}  ${sc.name}`;
-    if (sc.kind === 'modified') {
-      line += '  (signature changed)';
-    }
-    lines.push(line);
-  }
-
-  // Import changes
-  for (const ic of diff.imports) {
-    const glyph = CHANGE_GLYPH[ic.kind];
-    let line = `${glyph}  import  ${ic.specifier}`;
-    if (ic.names && ic.names.length > 0) {
-      const nameList = ic.names.slice(0, 4).join(', ');
-      const overflow = ic.names.length > 4 ? ` +${ic.names.length - 4} more` : '';
-      line += `  { ${nameList}${overflow} }`;
-    }
-    lines.push(line);
-  }
-
-  return lines;
-}
-
-/**
- * Render a one-line summary suitable for a status bar.
- * Example: "3 changes: +fn renderX  ~method Foo.bar  -import ./old"
- */
-export function formatSemanticDiffSummary(diff: SemanticDiff): string {
-  if (diff.totalChanges === 0) return '';
-  const parts = formatSemanticDiff(diff).slice(0, 3);
-  const overflow = diff.totalChanges > 3 ? `  +${diff.totalChanges - 3} more` : '';
-  return `${diff.totalChanges} semantic change${diff.totalChanges !== 1 ? 's' : ''}: ${parts.join('  ')}${overflow}`;
-}