memorylink 1.0.0

package/src/utils/tree-sitter-parser.ts

@@ -0,0 +1,246 @@
+/**
+ * MemoryLink - Tree-sitter Parser
+ * Multi-language AST parsing using Tree-sitter
+ * 
+ * v1.3: Week 7-8 - Python/Go Structure Support
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type { FileNode } from './code-structure.js';
+
+/**
+ * Check if Tree-sitter is available
+ */
+export function isTreeSitterAvailable(): boolean {
+  try {
+    require.resolve('tree-sitter');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Parse Python file using Tree-sitter
+ */
+export async function parsePythonFile(filepath: string, rootDir: string): Promise<FileNode | null> {
+  if (!isTreeSitterAvailable()) {
+    return null;
+  }
+
+  try {
+    // @ts-ignore - Optional dependency
+    const Parser = require('tree-sitter');
+    // @ts-ignore - Optional dependency
+    const Python = require('tree-sitter-python');
+
+    const parser = new Parser();
+    parser.setLanguage(Python);
+
+    const content = fs.readFileSync(filepath, 'utf-8');
+    const tree = parser.parse(content);
+    const stats = fs.statSync(filepath);
+
+    const imports: string[] = [];
+    const exports: string[] = [];
+    const functions: string[] = [];
+    const classes: string[] = [];
+
+    // Walk the tree to extract imports, functions, classes
+    const cursor = tree.walk();
+    let reachedRoot = false;
+
+    while (!reachedRoot) {
+      const node = cursor.currentNode();
+
+      if (node.type === 'import_statement' || node.type === 'import_from_statement') {
+        // Extract import path
+        const importText = content.substring(node.startIndex, node.endIndex);
+        const match = importText.match(/import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/);
+        if (match) {
+          imports.push(match[1]);
+        }
+      } else if (node.type === 'function_definition') {
+        // Extract function name
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          functions.push(nameNode.text);
+        }
+      } else if (node.type === 'class_definition') {
+        // Extract class name
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          classes.push(nameNode.text);
+        }
+      }
+
+      if (cursor.gotoFirstChild()) {
+        continue;
+      }
+      if (cursor.gotoNextSibling()) {
+        continue;
+      }
+
+      let retracing = true;
+      while (retracing) {
+        if (!cursor.gotoParent()) {
+          retracing = false;
+          reachedRoot = true;
+        }
+        if (cursor.gotoNextSibling()) {
+          retracing = false;
+        }
+      }
+    }
+
+    const lines = content.split('\n').length;
+    const complexity = calculateComplexity(content);
+
+    return {
+      path: normalizePathForGraph(filepath, rootDir),
+      imports,
+      exports, // Python doesn't have explicit exports like JS/TS
+      functions,
+      classes,
+      last_modified: stats.mtime.toISOString(),
+      risk_score: 0,
+      complexity,
+      lines,
+    };
+  } catch (error) {
+    console.warn(`Error parsing Python file ${filepath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    return null;
+  }
+}
+
+/**
+ * Parse Go file using Tree-sitter
+ */
+export async function parseGoFile(filepath: string, rootDir: string): Promise<FileNode | null> {
+  if (!isTreeSitterAvailable()) {
+    return null;
+  }
+
+  try {
+    // @ts-ignore - Optional dependency
+    const Parser = require('tree-sitter');
+    // @ts-ignore - Optional dependency
+    const Go = require('tree-sitter-go');
+
+    const parser = new Parser();
+    parser.setLanguage(Go);
+
+    const content = fs.readFileSync(filepath, 'utf-8');
+    const tree = parser.parse(content);
+    const stats = fs.statSync(filepath);
+
+    const imports: string[] = [];
+    const exports: string[] = [];
+    const functions: string[] = [];
+    const types: string[] = []; // Go uses types instead of classes
+
+    // Walk the tree to extract imports, functions, types
+    const cursor = tree.walk();
+    let reachedRoot = false;
+
+    while (!reachedRoot) {
+      const node = cursor.currentNode();
+
+      if (node.type === 'import_declaration') {
+        // Extract import path
+        const importText = content.substring(node.startIndex, node.endIndex);
+        const match = importText.match(/import\s+(?:\([^)]*\)|['"]([^'"]+)['"])/);
+        if (match) {
+          imports.push(match[1] || importText.replace(/import\s+/, '').replace(/['"]/g, ''));
+        }
+      } else if (node.type === 'method_declaration' || node.type === 'function_declaration') {
+        // Extract function/method name
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          functions.push(nameNode.text);
+        }
+      } else if (node.type === 'type_declaration') {
+        // Extract type name
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          types.push(nameNode.text);
+        }
+      }
+
+      if (cursor.gotoFirstChild()) {
+        continue;
+      }
+      if (cursor.gotoNextSibling()) {
+        continue;
+      }
+
+      let retracing = true;
+      while (retracing) {
+        if (!cursor.gotoParent()) {
+          retracing = false;
+          reachedRoot = true;
+        }
+        if (cursor.gotoNextSibling()) {
+          retracing = false;
+        }
+      }
+    }
+
+    const lines = content.split('\n').length;
+    const complexity = calculateComplexity(content);
+
+    return {
+      path: normalizePathForGraph(filepath, rootDir),
+      imports,
+      exports, // Go exports are capitalized identifiers
+      functions,
+      classes: types, // Map Go types to classes for compatibility
+      last_modified: stats.mtime.toISOString(),
+      risk_score: 0,
+      complexity,
+      lines,
+    };
+  } catch (error) {
+    console.warn(`Error parsing Go file ${filepath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    return null;
+  }
+}
+
+/**
+ * Normalize path for graph (same as code-structure.ts)
+ */
+function normalizePathForGraph(filepath: string, rootDir: string): string {
+  const relative = path.relative(rootDir, filepath);
+  return relative.replace(/\\/g, '/');
+}
+
+/**
+ * Calculate code complexity (simple heuristic)
+ */
+function calculateComplexity(content: string): number {
+  let complexity = 1; // Base complexity
+
+  // Count control flow statements
+  const controlFlowPatterns = [
+    /\bif\s*\(/g,
+    /\belse\s*{/g,
+    /\bfor\s*\(/g,
+    /\bwhile\s*\(/g,
+    /\bswitch\s*\(/g,
+    /\bcase\s+/g,
+    /\bcatch\s*\(/g,
+    /\bawait\s+/g,
+    /\breturn\s+/g,
+  ];
+
+  for (const pattern of controlFlowPatterns) {
+    const matches = content.match(pattern);
+    if (matches) {
+      complexity += matches.length;
+    }
+  }
+
+  return complexity;
+}
+

package/src/utils/v1.6-patterns.ts

@@ -0,0 +1,227 @@
+/**
+ * MemoryLink v1.6 - Enhanced Secret/PII Patterns
+ * 
+ * This file contains enhanced patterns for v1.6 that are currently commented out.
+ * Uncomment and integrate into src/commands/doctor.ts when implementing v1.6.
+ * 
+ * Design Notes:
+ * - Patterns use regex with appropriate flags
+ * - Entropy-based validation for high-confidence detection
+ * - Context-aware detection (e.g., CVV only near credit card patterns)
+ * - File-based logging detection (console.log with sensitive data)
+ */
+
+// ============================================
+// CREDIT CARD PATTERNS (v1.6)
+// ============================================
+
+/**
+ * Credit card number pattern (with Luhn validation)
+ * Formats: 1234 5678 9012 3456, 1234-5678-9012-3456, 1234567890123456
+ */
+export const CREDIT_CARD_PATTERN = /(?:\d{4}[-\s]?){3}\d{4}/g;
+
+/**
+ * Luhn algorithm validation for credit card numbers
+ * TODO v1.6: Implement Luhn check to reduce false positives
+ */
+export function validateLuhn(cardNumber: string): boolean {
+  // Remove spaces and dashes
+  const digits = cardNumber.replace(/[-\s]/g, '');
+  
+  // Must be 13-19 digits
+  if (digits.length < 13 || digits.length > 19) {
+    return false;
+  }
+  
+  // Luhn algorithm
+  let sum = 0;
+  let isEven = false;
+  
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let digit = parseInt(digits[i], 10);
+    
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9) {
+        digit -= 9;
+      }
+    }
+    
+    sum += digit;
+    isEven = !isEven;
+  }
+  
+  return sum % 10 === 0;
+}
+
+// ============================================
+// CVV PATTERNS (v1.6)
+// ============================================
+
+/**
+ * CVV pattern (3-4 digits, context-dependent)
+ * Only flag if found near credit card patterns or in payment context
+ */
+export const CVV_PATTERN = /\b\d{3,4}\b/g;
+
+/**
+ * Check if CVV is in payment context
+ * TODO v1.6: Context-aware detection
+ */
+export function isCVVContext(text: string, cvvMatch: string): boolean {
+  const context = text.substring(
+    Math.max(0, text.indexOf(cvvMatch) - 50),
+    Math.min(text.length, text.indexOf(cvvMatch) + 50)
+  );
+  
+  const paymentKeywords = ['cvv', 'cvc', 'security code', 'card', 'payment', 'billing'];
+  return paymentKeywords.some(keyword => 
+    context.toLowerCase().includes(keyword.toLowerCase())
+  );
+}
+
+// ============================================
+// SSN PATTERNS (v1.6)
+// ============================================
+
+/**
+ * SSN pattern (XXX-XX-XXXX)
+ * TODO v1.6: Validate first 3 digits (not 000, 666, 900-999)
+ */
+export const SSN_PATTERN = /\b\d{3}-\d{2}-\d{4}\b/g;
+
+/**
+ * Validate SSN format
+ */
+export function validateSSN(ssn: string): boolean {
+  const parts = ssn.split('-');
+  if (parts.length !== 3) return false;
+  
+  const area = parseInt(parts[0], 10);
+  const group = parseInt(parts[1], 10);
+  const serial = parseInt(parts[2], 10);
+  
+  // Invalid ranges
+  if (area === 0 || area === 666 || (area >= 900 && area <= 999)) {
+    return false;
+  }
+  
+  if (group === 0) return false;
+  if (serial === 0) return false;
+  
+  return true;
+}
+
+// ============================================
+// API KEY PATTERNS (v1.6)
+// ============================================
+
+/**
+ * Common API key patterns
+ * TODO v1.6: Add more patterns based on common services
+ */
+export const API_KEY_PATTERNS = [
+  { name: 'AWS Access Key', pattern: /AKIA[0-9A-Z]{16}/g },
+  { name: 'AWS Secret Key', pattern: /[A-Za-z0-9/+=]{40}/g },
+  { name: 'Google API Key', pattern: /AIza[0-9A-Za-z-_]{35}/g },
+  { name: 'GitHub Token', pattern: /ghp_[0-9A-Za-z]{36}/g },
+  { name: 'Stripe Live Key', pattern: /sk_live_[0-9a-zA-Z]{24,}/g },
+  { name: 'Stripe Test Key', pattern: /sk_test_[0-9a-zA-Z]{24,}/g },
+  { name: 'Generic API Key', pattern: /[A-Za-z0-9]{32,}/g }, // High entropy, 32+ chars
+];
+
+// ============================================
+// FILE-BASED LOGGING DETECTION (v1.6)
+// ============================================
+
+/**
+ * Detect sensitive data in logging statements
+ * Patterns: console.log, logger.info, etc. with sensitive data
+ */
+export const LOGGING_PATTERNS = [
+  { name: 'Console Log with Secret', pattern: /console\.(log|info|warn|error)\([^)]*(?:password|secret|key|token|api)[^)]*\)/gi },
+  { name: 'Logger with Secret', pattern: /logger\.(info|warn|error|debug)\([^)]*(?:password|secret|key|token|api)[^)]*\)/gi },
+];
+
+/**
+ * Check if logging statement contains sensitive data
+ */
+export function isSensitiveLogging(line: string): boolean {
+  // Check for logging patterns
+  for (const pattern of LOGGING_PATTERNS) {
+    if (pattern.pattern.test(line)) {
+      return true;
+    }
+  }
+  
+  // Check for common sensitive keywords in logging context
+  const sensitiveKeywords = ['password', 'secret', 'api_key', 'token', 'auth', 'credential'];
+  const hasLogging = /console\.|logger\.|log\(/i.test(line);
+  const hasSensitive = sensitiveKeywords.some(keyword => 
+    new RegExp(keyword, 'i').test(line)
+  );
+  
+  return hasLogging && hasSensitive;
+}
+
+// ============================================
+// INTEGRATION NOTES (v1.6)
+// ============================================
+
+/**
+ * To integrate these patterns into doctor.ts:
+ * 
+ * 1. Import patterns:
+ *    import { CREDIT_CARD_PATTERN, validateLuhn, ... } from '../utils/v1.6-patterns.js';
+ * 
+ * 2. Add to validateSecurity():
+ *    // Credit cards
+ *    const cardMatches = content.match(CREDIT_CARD_PATTERN);
+ *    if (cardMatches && validateLuhn(cardMatches[0])) {
+ *      issues.push({ type: 'SECRET', severity: 'error', ... });
+ *    }
+ * 
+ *    // CVV (context-aware)
+ *    const cvvMatches = content.match(CVV_PATTERN);
+ *    for (const match of cvvMatches) {
+ *      if (isCVVContext(content, match)) {
+ *        issues.push({ type: 'SECRET', severity: 'error', ... });
+ *      }
+ *    }
+ * 
+ *    // SSN
+ *    const ssnMatches = content.match(SSN_PATTERN);
+ *    for (const match of ssnMatches) {
+ *      if (validateSSN(match)) {
+ *        issues.push({ type: 'PII', severity: 'error', ... });
+ *      }
+ *    }
+ * 
+ *    // API keys
+ *    for (const pattern of API_KEY_PATTERNS) {
+ *      const matches = content.match(pattern.pattern);
+ *      if (matches) {
+ *        issues.push({ type: 'SECRET', severity: 'error', ... });
+ *      }
+ *    }
+ * 
+ * 3. Add file-based logging detection:
+ *    // In postflight check, scan changed files for sensitive logging
+ *    const changedFiles = getChangedFiles(root);
+ *    for (const file of changedFiles) {
+ *      const fileContent = fs.readFileSync(path.join(root, file), 'utf-8');
+ *      const lines = fileContent.split('\n');
+ *      for (let i = 0; i < lines.length; i++) {
+ *        if (isSensitiveLogging(lines[i])) {
+ *          issues.push({
+ *            type: 'SECRET',
+ *            severity: 'error',
+ *            message: `Sensitive data in logging: ${file}:${i + 1}`,
+ *            ...
+ *          });
+ *        }
+ *      }
+ *    }
+ */
+