skannr 0.2.0 → 0.2.2

package/src/guard/symbol-diff.ts

@@ -0,0 +1,227 @@
+/**
+ * Build symbol-level diff units from staged git changes.
+ * Uses Skannr's existing parser to identify which symbols changed,
+ * instead of working with raw file diffs.
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { getAdapter } from '../languages/registry';
+import { readFileContent } from '../scanner';
+import type { Symbol } from '../languages/LanguageAdapter';
+import type { SymbolDiffUnit } from './types';
+
+/** Get the list of staged files (paths relative to root). */
+export function getStagedFiles(root: string): string[] {
+  try {
+    const output = execSync('git diff --cached --name-only --diff-filter=ACMR', {
+      cwd: root,
+      encoding: 'utf-8',
+    });
+    return output.trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/** Get the diff text for a specific staged file. */
+function getStagedDiff(root: string, file: string): string {
+  try {
+    return execSync(`git diff --cached -- "${file}"`, {
+      cwd: root,
+      encoding: 'utf-8',
+      maxBuffer: 5 * 1024 * 1024,
+    });
+  } catch {
+    return '';
+  }
+}
+
+/** Get the old (HEAD) version of a file, or null if newly added. */
+function getHeadContent(root: string, file: string): string | null {
+  try {
+    return execSync(`git show HEAD:"${file}"`, {
+      cwd: root,
+      encoding: 'utf-8',
+      maxBuffer: 5 * 1024 * 1024,
+    });
+  } catch {
+    return null;
+  }
+}
+
+/** Extract changed line numbers from a unified diff. */
+function extractChangedLines(diff: string): Set<number> {
+  const lines = new Set<number>();
+  let currentLine = 0;
+
+  for (const line of diff.split('\n')) {
+    const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)/);
+    if (hunkMatch) {
+      currentLine = parseInt(hunkMatch[1], 10);
+      continue;
+    }
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      lines.add(currentLine);
+      currentLine++;
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      // Deleted lines don't advance the new-file line counter
+    } else {
+      currentLine++;
+    }
+  }
+
+  return lines;
+}
+
+/**
+ * Determine which symbols in a file were affected by the staged changes.
+ * Matches symbols whose line range overlaps any changed line.
+ */
+function findAffectedSymbols(
+  symbols: Symbol[],
+  changedLines: Set<number>,
+  allSymbols: Symbol[],
+): Symbol[] {
+  if (changedLines.size === 0) return [];
+
+  // Build approximate end lines: each symbol extends until the next symbol starts
+  const sorted = [...allSymbols].sort((a, b) => a.line - b.line);
+  const affected: Symbol[] = [];
+
+  for (let i = 0; i < sorted.length; i++) {
+    const sym = sorted[i];
+    const startLine = sym.line;
+    const endLine = i + 1 < sorted.length ? sorted[i + 1].line - 1 : startLine + 50;
+
+    for (let line = startLine; line <= endLine; line++) {
+      if (changedLines.has(line)) {
+        affected.push(sym);
+        break;
+      }
+    }
+  }
+
+  return affected;
+}
+
+/**
+ * Build symbol-level diff units for all staged files in the project.
+ * This is the primary input to the review runner.
+ */
+export function buildSymbolDiffs(root: string): SymbolDiffUnit[] {
+  const stagedFiles = getStagedFiles(root);
+  const units: SymbolDiffUnit[] = [];
+
+  for (const relFile of stagedFiles) {
+    const absPath = path.join(root, relFile);
+    if (!fs.existsSync(absPath)) continue;
+
+    const adapter = getAdapter(absPath);
+    const newContent = readFileContent(absPath);
+    if (!newContent) continue;
+
+    const newSymbols = adapter.extractSymbols(newContent);
+    const oldContent = getHeadContent(root, relFile);
+    const oldSymbols = oldContent ? adapter.extractSymbols(oldContent) : [];
+
+    const diff = getStagedDiff(root, relFile);
+    const changedLines = extractChangedLines(diff);
+
+    // Find symbols that overlap changed lines in the new version
+    const affected = findAffectedSymbols(newSymbols, changedLines, newSymbols);
+
+    // Determine change type for each affected symbol
+    const oldSymbolNames = new Set(oldSymbols.map((s) => s.name));
+
+    for (const sym of affected) {
+      if (sym.kind === 'export') continue; // skip synthetic export markers
+
+      const changeType = oldSymbolNames.has(sym.name) ? 'modified' : 'added';
+      const oldSym = oldSymbols.find((s) => s.name === sym.name);
+
+      units.push({
+        file: relFile,
+        symbol: sym.name,
+        changeType,
+        oldSignature: oldSym ? `${oldSym.kind} ${oldSym.name}` : undefined,
+        newSignature: `${sym.kind} ${sym.name}`,
+        callers: [],  // populated by call-context module
+        callees: [],  // populated by call-context module
+        diffText: diff,
+      });
+    }
+
+    // Handle deleted symbols (in old but not in new)
+    if (oldContent) {
+      const newSymbolNames = new Set(newSymbols.map((s) => s.name));
+      for (const oldSym of oldSymbols) {
+        if (oldSym.kind === 'export') continue;
+        if (!newSymbolNames.has(oldSym.name)) {
+          units.push({
+            file: relFile,
+            symbol: oldSym.name,
+            changeType: 'deleted',
+            oldSignature: `${oldSym.kind} ${oldSym.name}`,
+            callers: [],
+            callees: [],
+            diffText: diff,
+          });
+        }
+      }
+    }
+  }
+
+  return units;
+}
+
+/**
+ * Build symbol diffs from a PR diff string (for --pr-mode).
+ */
+export function buildSymbolDiffsFromDiff(root: string, diffContent: string): SymbolDiffUnit[] {
+  const parseDiff = require('parse-diff');
+  const parsedFiles = parseDiff(diffContent);
+  const units: SymbolDiffUnit[] = [];
+
+  for (const file of parsedFiles) {
+    const raw = file.to ?? file.from;
+    if (!raw || raw === '/dev/null') continue;
+    const relFile = raw.replace(/^[ab]\//, '');
+    const absPath = path.join(root, relFile);
+    if (!fs.existsSync(absPath)) continue;
+
+    const adapter = getAdapter(absPath);
+    const content = readFileContent(absPath);
+    if (!content) continue;
+
+    const symbols = adapter.extractSymbols(content);
+    const changedLines = new Set<number>();
+
+    for (const chunk of file.chunks) {
+      for (const change of chunk.changes) {
+        if (change.type === 'add' || change.type === 'del') {
+          const ln = (change as any).ln;
+          if (typeof ln === 'number') changedLines.add(ln);
+        }
+      }
+    }
+
+    const affected = findAffectedSymbols(symbols, changedLines, symbols);
+
+    for (const sym of affected) {
+      if (sym.kind === 'export') continue;
+      units.push({
+        file: relFile,
+        symbol: sym.name,
+        changeType: 'modified',
+        newSignature: `${sym.kind} ${sym.name}`,
+        callers: [],
+        callees: [],
+        diffText: file.chunks.map((c: any) => c.content).join('\n'),
+      });
+    }
+  }
+
+  return units;
+}

package/src/guard/types.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared type definitions for the guard module.
+ */
+
+/** Severity levels for rules and violations. */
+export type Severity = 'low' | 'medium' | 'high' | 'critical';
+
+/** A team-defined review rule. */
+export interface GuardRule {
+  id: string;
+  description: string;
+  severity: Severity;
+  fixable: boolean;
+  category: string;
+}
+
+/** A single symbol-level diff unit sent to the LLM for review. */
+export interface SymbolDiffUnit {
+  file: string;
+  symbol: string;
+  changeType: 'added' | 'modified' | 'deleted';
+  oldSignature?: string;
+  newSignature?: string;
+  callers: string[];
+  callees: string[];
+  diffText: string;
+}
+
+/** A violation found by the review. */
+export interface Violation {
+  rule_id: string;
+  file: string;
+  symbol: string;
+  line_start: number;
+  line_end: number;
+  severity: Severity;
+  confidence: number;
+  fixable: boolean;
+  message: string;
+  suggested_fix?: string;
+}
+
+/** The structured response contract from the LLM. */
+export interface ReviewResponse {
+  violations: Violation[];
+  status: 'pass' | 'fail';
+  summary: string;
+}
+
+/** Result of a full guard run. */
+export interface GuardResult {
+  response: ReviewResponse;
+  rulesUsed: GuardRule[];
+  symbolsReviewed: number;
+  durationMs: number;
+}
+
+/** Guard configuration (provider, model, etc.). */
+export interface GuardConfig {
+  /** LLM provider: 'gemini' | 'openai' */
+  provider: 'gemini' | 'openai';
+  /** Model name (e.g. 'gemini-2.0-flash-exp', 'gpt-4o'). */
+  model: string;
+  /** API key (resolved from env if not set). */
+  apiKey?: string;
+  /** OpenAI-compatible base URL (for openai provider). */
+  baseUrl?: string;
+}

package/src/index.ts

@@ -3,7 +3,7 @@
  */
 
 import * as path from 'path';
-import { discoverModules, readFileContent, scanFiles, scanRocketChatFiles, scanTypeScriptFiles } from './scanner';
+import { discoverModules, readFileContent, scanFiles, scanTypeScriptFiles } from './scanner';
 import { rankFiles } from './ranker';
 import { rankFilesEnhanced } from './ranker-enhanced';
 import { buildSkeletonForFile } from './skeletonizer';
@@ -194,7 +194,7 @@ function resolveExtensions(
 export { rankFiles } from './ranker';
 export { rankFilesEnhanced } from './ranker-enhanced';
 export { buildSkeletonForFile } from './skeletonizer';
-export { scanTypeScriptFiles, scanRocketChatFiles, scanFiles, discoverModules } from './scanner';
+export { scanTypeScriptFiles, scanFiles, discoverModules } from './scanner';
 export { countTokens } from './tokenizer';
 export {
   buildSkeletonWithMapping,

package/src/mcp-server.ts

@@ -84,6 +84,33 @@ export async function startMcpServer(): Promise<void> {
           required: ['root'],
         },
       },
+      {
+        name: 'guard_review',
+        description:
+          'Review staged or diff changes against team-defined rules. Returns structured violations with severity, confidence, and fixability.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: {
+              type: 'string',
+              description: 'Absolute path to the repo root',
+            },
+            diff: {
+              type: 'string',
+              description: 'Unified diff content (if omitted, reviews staged files)',
+            },
+            diff_only: {
+              type: 'boolean',
+              description: 'Skip cross-file context for faster review (default: false)',
+            },
+            fix: {
+              type: 'boolean',
+              description: 'Apply auto-fixes for fixable violations (default: false)',
+            },
+          },
+          required: ['root'],
+        },
+      },
     ],
   }));
 
@@ -143,6 +170,28 @@ export async function startMcpServer(): Promise<void> {
       };
     }
 
+    if (toolName === 'guard_review') {
+      const { runGuard, formatGuardJson } = await import('./guard/index');
+      const root = String(args.root ?? '');
+      const diffContent =
+        typeof args.diff === 'string' && args.diff.length > 0
+          ? args.diff
+          : undefined;
+      const diffOnly = args.diff_only === true;
+      const fix = args.fix === true;
+
+      const { result } = await runGuard({
+        root,
+        diffOnly,
+        fix,
+        ...(diffContent ? { prMode: false } : {}),
+      });
+
+      return {
+        content: [{ type: 'text', text: formatGuardJson(result) }],
+      };
+    }
+
     throw new Error(`Unknown tool: ${toolName}`);
   });
 

package/src/scanner.ts

@@ -145,13 +145,6 @@ export function scanTypeScriptFiles(rootDir: string): string[] {
   return scanFiles(rootDir, { extensions: ['.ts', '.tsx'] });
 }
 
-export function scanRocketChatFiles(rootDir: string, moduleKeys?: string[]): string[] {
-  return scanFiles(rootDir, {
-    extensions: ['.ts', '.tsx'],
-    moduleKeys,
-  });
-}
-
 export function readFileContent(filePath: string): string | null {
   try {
     return fs.readFileSync(filePath, 'utf-8');

package/gemini-extension/GEMINI.md

@@ -1,26 +0,0 @@
-# Universal Code Analyzer
-
-You have a tool called `scan_codebase` that scans any repository and returns compressed **skeletons** — function signatures and types without the full implementation bodies.
-
-## When to use it
-
-Use `scan_codebase` before reading source files. It tells you which files are relevant and shows their structure without burning tokens on full file contents.
-
-## Parameters
-
-- `question` (**required**): what you want to understand, e.g. `"how are messages sent?"`
-- `root` (**required**): absolute path to the repository, e.g. `/home/user/my-project`
-- `limit`: how many files to return (default: 10)
-- `modules`: narrow the search to specific modules or directories
-
-## Example
-
-```
-scan_codebase({
-  question: "How does the authentication flow work?",
-  root: "/home/user/my-project",
-  modules: ["auth"]
-})
-```
-
-The response includes each file's path, relevance score, skeleton code, and token counts so you can decide what to read in full.

package/gemini-extension/gemini-extension.json

@@ -1,12 +0,0 @@
-{
-  "name": "code-analyzer",
-  "version": "0.1.0",
-  "description": "Analyze any codebase and return token-efficient structural skeletons",
-  "mcpServers": {
-    "code-analyzer": {
-      "command": "node",
-      "args": ["${extensionPath}/dist/server.js"]
-    }
-  },
-  "contextFileName": "GEMINI.md"
-}

package/gemini-extension/package.json

@@ -1,14 +0,0 @@
-{
-  "name": "code-analyzer-extension",
-  "version": "0.1.0",
-  "scripts": {
-    "build": "tsc"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.3.0"
-  }
-}

package/gemini-extension/src/server.ts

@@ -1,69 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { analyzeProject } from '../../dist/index';
-
-const server = new Server(
-  { name: 'code-analyzer', version: '0.1.0' },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: 'scan_codebase',
-      description: 'Analyzes any codebase to answer questions about its structure and architecture. Scans files, generates structural skeletons, and ranks results using hybrid retrieval. Supports TypeScript, JavaScript, and Python. Pass the root path of any repository.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          question: {
-            type: 'string',
-            description: 'What you want to understand about the codebase',
-          },
-          root: {
-            type: 'string',
-            description: 'Absolute path to the repository root',
-          },
-          limit: {
-            type: 'number',
-            description: 'Max number of files to return (default: 10)',
-          },
-          modules: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Optional module keys (or directory names) to narrow the search scope',
-          },
-        },
-        required: ['question', 'root'],
-      },
-    },
-  ],
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  if (request.params.name !== 'scan_codebase') {
-    throw new Error(`Unknown tool: ${request.params.name}`);
-  }
-
-  const { question, root, limit = 10, modules } = request.params.arguments as {
-    question: string;
-    root: string;
-    limit?: number;
-    modules?: string[];
-  };
-
-  const result = await analyzeProject({
-    question,
-    root,
-    limit,
-    moduleKeys: modules,
-    enhancedRanking: true,
-  });
-
-  return {
-    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-  };
-});
-
-const transport = new StdioServerTransport();
-server.connect(transport).catch(console.error);

package/gemini-extension/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "moduleResolution": "node",
-    "types": ["node"]
-  },
-  "include": ["src/**/*"]
-}