@massu/core 0.1.1 → 0.4.0

package/src/python/migration-parser.ts

@@ -0,0 +1,332 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+export interface MigrationOperation {
+  type:
+    | 'create_table'
+    | 'drop_table'
+    | 'add_column'
+    | 'drop_column'
+    | 'alter_column'
+    | 'create_index'
+    | 'other';
+  table?: string;
+  column?: string;
+  details?: string;
+}
+
+export interface ParsedMigration {
+  revision: string;
+  downRevision: string | null;
+  description: string | null;
+  operations: MigrationOperation[];
+}
+
+/**
+ * Extract a string assignment value from source.
+ * Handles: revision = 'abc123' and revision = "abc123"
+ */
+function extractStringVar(source: string, varName: string): string | null {
+  const re = new RegExp(`^${varName}\\s*(?::\\s*\\w+)?\\s*=\\s*['"]([^'"]*)['"]\s*$`, 'm');
+  const m = source.match(re);
+  return m ? m[1] : null;
+}
+
+/**
+ * Extract a variable that can be a string or None.
+ * Handles: down_revision = None, down_revision = 'abc', down_revision: ... = None
+ */
+function extractNullableStringVar(source: string, varName: string): string | null {
+  // Check for None first
+  const noneRe = new RegExp(`^${varName}\\s*(?::\\s*[^=]+)?\\s*=\\s*None\\s*$`, 'm');
+  if (noneRe.test(source)) return null;
+
+  return extractStringVar(source, varName);
+}
+
+/**
+ * Extract the description from the module docstring or revision message.
+ * Alembic typically puts it in a comment like: """description here"""
+ * or in the Revision ID comment block.
+ */
+function extractDescription(source: string): string | null {
+  // Try triple-quoted module docstring
+  const docMatch = source.match(/^"""(.*?)"""/ms);
+  if (docMatch) {
+    const firstLine = docMatch[1].trim().split('\n')[0].trim();
+    if (firstLine && !firstLine.startsWith('Revision ID')) {
+      return firstLine;
+    }
+  }
+
+  // Try single-line comment after "Revises:" block
+  const descMatch = source.match(/^#\s*Revision ID:\s*\w+\n#\s*Revises:\s*\w*\n#\s*Create Date:\s*.+\n\n"""(.+?)"""/m);
+  if (descMatch) return descMatch[1].trim();
+
+  // Try the first triple-quoted string content that looks like a description
+  const tripleMatch = source.match(/"""([^"]+?)(?:\n\nRevision ID|\n\n|""")/);
+  if (tripleMatch) {
+    const desc = tripleMatch[1].trim();
+    if (desc && desc.length < 200) return desc;
+  }
+
+  return null;
+}
+
+/**
+ * Extract the body of the upgrade() function.
+ */
+function extractFunctionBody(source: string, funcName: string): string {
+  const funcRe = new RegExp(`^def\\s+${funcName}\\s*\\([^)]*\\)\\s*(?:->\\s*\\w+)?\\s*:`, 'm');
+  const match = funcRe.exec(source);
+  if (!match) return '';
+
+  const startIndex = match.index + match[0].length;
+  const lines = source.substring(startIndex).split('\n');
+  const bodyLines: string[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // Empty lines are part of the body
+    if (line.trim() === '') {
+      bodyLines.push(line);
+      continue;
+    }
+    // If line starts with indent (space or tab), it's part of the body
+    if (line.startsWith(' ') || line.startsWith('\t')) {
+      bodyLines.push(line);
+    } else {
+      // Hit a non-indented line — end of function
+      break;
+    }
+  }
+
+  return bodyLines.join('\n');
+}
+
+/**
+ * Extract the first quoted string argument from an op call.
+ * e.g., op.create_table('users', ...) -> 'users'
+ */
+function extractFirstStringArg(argsStr: string): string | null {
+  const m = argsStr.match(/['"]([^'"]+)['"]/);
+  return m ? m[1] : null;
+}
+
+/**
+ * Extract table and column from op calls that take (table, column, ...).
+ * e.g., op.add_column('users', sa.Column('email', ...)) -> { table: 'users', column: 'email' }
+ */
+function extractTableAndColumn(argsStr: string): { table: string | null; column: string | null } {
+  const parts = splitTopLevelCommas(argsStr);
+  const table = parts[0] ? extractFirstStringArg(parts[0]) : null;
+
+  // For add_column, the second arg is sa.Column('name', ...)
+  let column: string | null = null;
+  if (parts[1]) {
+    const colMatch = parts[1].match(/Column\s*\(\s*['"]([^'"]+)['"]/);
+    if (colMatch) {
+      column = colMatch[1];
+    } else {
+      // For drop_column, it's just a string: op.drop_column('table', 'column')
+      column = extractFirstStringArg(parts[1]);
+    }
+  }
+
+  return { table, column };
+}
+
+/**
+ * Split a string by top-level commas (not inside parens/brackets/strings).
+ */
+function splitTopLevelCommas(text: string): string[] {
+  const parts: string[] = [];
+  let current = '';
+  let depth = 0;
+  let inString: string | null = null;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+
+    if (inString) {
+      current += ch;
+      if (ch === inString && text[i - 1] !== '\\') {
+        inString = null;
+      }
+      continue;
+    }
+
+    if (ch === "'" || ch === '"') {
+      inString = ch;
+      current += ch;
+      continue;
+    }
+
+    if (ch === '(' || ch === '[') {
+      depth++;
+      current += ch;
+    } else if (ch === ')' || ch === ']') {
+      depth = Math.max(0, depth - 1);
+      current += ch;
+    } else if (ch === ',' && depth === 0) {
+      parts.push(current.trim());
+      current = '';
+    } else {
+      current += ch;
+    }
+  }
+
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+
+/**
+ * Parse operations from the upgrade function body.
+ */
+function parseOperations(body: string): MigrationOperation[] {
+  const operations: MigrationOperation[] = [];
+
+  // Join multi-line op calls
+  const joinedBody = joinOpCalls(body);
+  const lines = joinedBody.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // op.create_table(...)
+    const createTableMatch = trimmed.match(/op\.create_table\s*\((.+)\)/s);
+    if (createTableMatch) {
+      const tableName = extractFirstStringArg(createTableMatch[1]);
+      operations.push({
+        type: 'create_table',
+        table: tableName || undefined,
+      });
+      continue;
+    }
+
+    // op.drop_table(...)
+    const dropTableMatch = trimmed.match(/op\.drop_table\s*\((.+)\)/s);
+    if (dropTableMatch) {
+      const tableName = extractFirstStringArg(dropTableMatch[1]);
+      operations.push({
+        type: 'drop_table',
+        table: tableName || undefined,
+      });
+      continue;
+    }
+
+    // op.add_column(...)
+    const addColMatch = trimmed.match(/op\.add_column\s*\((.+)\)/s);
+    if (addColMatch) {
+      const { table, column } = extractTableAndColumn(addColMatch[1]);
+      operations.push({
+        type: 'add_column',
+        table: table || undefined,
+        column: column || undefined,
+      });
+      continue;
+    }
+
+    // op.drop_column(...)
+    const dropColMatch = trimmed.match(/op\.drop_column\s*\((.+)\)/s);
+    if (dropColMatch) {
+      const { table, column } = extractTableAndColumn(dropColMatch[1]);
+      operations.push({
+        type: 'drop_column',
+        table: table || undefined,
+        column: column || undefined,
+      });
+      continue;
+    }
+
+    // op.alter_column(...)
+    const alterColMatch = trimmed.match(/op\.alter_column\s*\((.+)\)/s);
+    if (alterColMatch) {
+      const { table, column } = extractTableAndColumn(alterColMatch[1]);
+      operations.push({
+        type: 'alter_column',
+        table: table || undefined,
+        column: column || undefined,
+        details: trimmed,
+      });
+      continue;
+    }
+
+    // op.create_index(...)
+    const createIdxMatch = trimmed.match(/op\.create_index\s*\((.+)\)/s);
+    if (createIdxMatch) {
+      const parts = splitTopLevelCommas(createIdxMatch[1]);
+      const indexName = parts[0] ? extractFirstStringArg(parts[0]) : null;
+      const tableName = parts[1] ? extractFirstStringArg(parts[1]) : null;
+      operations.push({
+        type: 'create_index',
+        table: tableName || undefined,
+        details: indexName ? `index: ${indexName}` : undefined,
+      });
+      continue;
+    }
+
+    // Any other op.xxx(...) call
+    const otherOpMatch = trimmed.match(/op\.(\w+)\s*\((.+)\)/s);
+    if (otherOpMatch) {
+      operations.push({
+        type: 'other',
+        details: `op.${otherOpMatch[1]}(...)`,
+      });
+    }
+  }
+
+  return operations;
+}
+
+/**
+ * Join multi-line op.xxx() calls into single lines.
+ */
+function joinOpCalls(body: string): string {
+  const lines = body.split('\n');
+  const result: string[] = [];
+  let current = '';
+  let openParens = 0;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (current === '' && !trimmed.startsWith('op.')) {
+      result.push(line);
+      continue;
+    }
+
+    current += (current ? ' ' : '') + trimmed;
+
+    for (const ch of trimmed) {
+      if (ch === '(') openParens++;
+      else if (ch === ')') openParens = Math.max(0, openParens - 1);
+    }
+
+    if (openParens === 0) {
+      result.push(current);
+      current = '';
+    }
+  }
+
+  if (current) result.push(current);
+  return result.join('\n');
+}
+
+/**
+ * Parse an Alembic migration file and extract revision info and operations.
+ */
+export function parseAlembicMigration(source: string): ParsedMigration {
+  const revision = extractStringVar(source, 'revision') || '';
+  const downRevision = extractNullableStringVar(source, 'down_revision');
+  const description = extractDescription(source);
+
+  const upgradeBody = extractFunctionBody(source, 'upgrade');
+  const operations = parseOperations(upgradeBody);
+
+  return {
+    revision,
+    downRevision,
+    description,
+    operations,
+  };
+}

package/src/python/model-indexer.ts

@@ -0,0 +1,70 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+import { readFileSync, readdirSync } from 'fs';
+import { join, relative } from 'path';
+import type Database from 'better-sqlite3';
+import { parsePythonModels } from './model-parser.ts';
+import { getProjectRoot } from '../config.ts';
+
+function walkPyFiles(dir: string, excludeDirs: string[]): string[] {
+  const files: string[] = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (excludeDirs.includes(entry.name)) continue;
+        files.push(...walkPyFiles(join(dir, entry.name), excludeDirs));
+      } else if (entry.name.endsWith('.py')) {
+        files.push(join(dir, entry.name));
+      }
+    }
+  } catch { /* dir not readable, skip */ }
+  return files;
+}
+
+export function buildPythonModelIndex(dataDb: Database.Database, pythonRoot: string, excludeDirs: string[] = ['__pycache__', '.venv', 'venv', '.mypy_cache', '.pytest_cache']): number {
+  const projectRoot = getProjectRoot();
+  const absRoot = join(projectRoot, pythonRoot);
+  dataDb.exec('DELETE FROM massu_py_models');
+  dataDb.exec('DELETE FROM massu_py_fk_edges');
+
+  const insertModel = dataDb.prepare(
+    'INSERT INTO massu_py_models (class_name, table_name, file, line, columns, relationships, foreign_keys) VALUES (?, ?, ?, ?, ?, ?, ?)'
+  );
+  const insertFk = dataDb.prepare(
+    'INSERT INTO massu_py_fk_edges (source_table, source_column, target_table, target_column) VALUES (?, ?, ?, ?)'
+  );
+
+  const files = walkPyFiles(absRoot, excludeDirs);
+  let count = 0;
+
+  dataDb.transaction(() => {
+    for (const absFile of files) {
+      const relFile = relative(projectRoot, absFile);
+      let source: string;
+      try { source = readFileSync(absFile, 'utf-8'); } catch { continue; }
+
+      const models = parsePythonModels(source);
+      for (const model of models) {
+        insertModel.run(
+          model.className, model.tableName, relFile, model.line,
+          JSON.stringify(model.columns), JSON.stringify(model.relationships), JSON.stringify(model.foreignKeys)
+        );
+        count++;
+
+        // Build FK edges
+        if (model.tableName) {
+          for (const fk of model.foreignKeys) {
+            const [targetTable, targetColumn] = fk.target.split('.');
+            if (targetTable && targetColumn) {
+              insertFk.run(model.tableName, fk.column, targetTable, targetColumn);
+            }
+          }
+        }
+      }
+    }
+  })();
+
+  return count;
+}

package/src/python/model-parser.ts

@@ -0,0 +1,279 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+export interface ModelColumn {
+  name: string;
+  type: string;
+  nullable: boolean;
+  primaryKey: boolean;
+}
+
+export interface ModelRelationship {
+  name: string;
+  target: string;
+  back_populates: string | null;
+}
+
+export interface ModelForeignKey {
+  column: string;
+  target: string; // "table.column"
+}
+
+export interface ParsedModel {
+  className: string;
+  tableName: string | null;
+  columns: ModelColumn[];
+  relationships: ModelRelationship[];
+  foreignKeys: ModelForeignKey[];
+  line: number;
+}
+
+/** Known SA base classes that indicate a model class. */
+const BASE_CLASSES = new Set(['Base', 'DeclarativeBase', 'db.Model']);
+
+/**
+ * Check if a class definition inherits from a known SQLAlchemy base.
+ */
+function isModelClass(bases: string): boolean {
+  const parts = bases.split(',').map((s) => s.trim());
+  return parts.some((b) => BASE_CLASSES.has(b));
+}
+
+/**
+ * Extract type name from SA 1.x Column() first argument.
+ * e.g., Column(Integer, ...) -> "Integer"
+ * e.g., Column(String(255), ...) -> "String(255)"
+ */
+function extractColumnType(argsStr: string): string {
+  const trimmed = argsStr.trim();
+  // Match the first argument which is the type
+  // Handle callable types like String(255), Numeric(10,2)
+  const m = trimmed.match(/^([A-Za-z_]\w*(?:\([^)]*\))?)/);
+  return m ? m[1] : 'Unknown';
+}
+
+/**
+ * Extract type from Mapped[type] annotation.
+ * e.g., Mapped[int] -> "int", Mapped[Optional[str]] -> "Optional[str]"
+ */
+function extractMappedType(annotation: string): string {
+  const m = annotation.match(/Mapped\[(.+)\]/);
+  return m ? m[1] : annotation;
+}
+
+/**
+ * Check if args contain nullable=False or nullable=True.
+ * Default depends on context: Column defaults to nullable=True.
+ */
+function extractNullable(argsStr: string): boolean {
+  const m = argsStr.match(/nullable\s*=\s*(True|False)/);
+  if (m) return m[1] === 'True';
+  // Default: nullable=True for Column, for Mapped it depends on Optional
+  return true;
+}
+
+/**
+ * Check if args contain primary_key=True.
+ */
+function extractPrimaryKey(argsStr: string): boolean {
+  return /primary_key\s*=\s*True/.test(argsStr);
+}
+
+/**
+ * Extract ForeignKey target from Column args.
+ * e.g., Column(Integer, ForeignKey("users.id")) -> "users.id"
+ */
+function extractForeignKeys(columnName: string, argsStr: string): ModelForeignKey[] {
+  const keys: ModelForeignKey[] = [];
+  const re = /ForeignKey\(\s*['"]([^'"]+)['"]\s*\)/g;
+  let match;
+  while ((match = re.exec(argsStr)) !== null) {
+    keys.push({ column: columnName, target: match[1] });
+  }
+  return keys;
+}
+
+/**
+ * Extract relationship target and back_populates.
+ * e.g., relationship("User", back_populates="posts") -> { target: "User", back_populates: "posts" }
+ */
+function parseRelationship(argsStr: string): { target: string; back_populates: string | null } | null {
+  const targetMatch = argsStr.match(/['"](\w+)['"]/);
+  if (!targetMatch) return null;
+
+  const bpMatch = argsStr.match(/back_populates\s*=\s*['"](\w+)['"]/);
+  return {
+    target: targetMatch[1],
+    back_populates: bpMatch ? bpMatch[1] : null,
+  };
+}
+
+/**
+ * Find the matching closing paren/bracket, handling nesting.
+ */
+function findClosingParen(text: string, openIndex: number, openChar: string, closeChar: string): number {
+  let depth = 1;
+  for (let i = openIndex + 1; i < text.length; i++) {
+    if (text[i] === openChar) depth++;
+    else if (text[i] === closeChar) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Get the full argument string inside balanced parentheses starting after a keyword.
+ * Returns the content between the outermost parens.
+ */
+function getBalancedArgs(line: string, keyword: string): string | null {
+  const idx = line.indexOf(keyword);
+  if (idx === -1) return null;
+  const parenStart = line.indexOf('(', idx + keyword.length);
+  if (parenStart === -1) return null;
+  const parenEnd = findClosingParen(line, parenStart, '(', ')');
+  if (parenEnd === -1) return null;
+  return line.substring(parenStart + 1, parenEnd);
+}
+
+/**
+ * Parse SQLAlchemy model definitions from Python source code.
+ */
+export function parsePythonModels(source: string): ParsedModel[] {
+  const models: ParsedModel[] = [];
+  const lines = source.split('\n');
+
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const classMatch = line.match(/^class\s+(\w+)\s*\(([^)]+)\)\s*:/);
+
+    if (!classMatch) {
+      i++;
+      continue;
+    }
+
+    const className = classMatch[1];
+    const bases = classMatch[2];
+    const classLine = i + 1; // 1-based
+
+    // Determine if this is a model class
+    let isModel = isModelClass(bases);
+
+    // We'll also check for __tablename__ inside the class body
+    const columns: ModelColumn[] = [];
+    const relationships: ModelRelationship[] = [];
+    const foreignKeys: ModelForeignKey[] = [];
+    let tableName: string | null = null;
+
+    i++;
+
+    // Parse class body (indented lines)
+    while (i < lines.length) {
+      const bodyLine = lines[i];
+
+      // End of class body: non-empty line at column 0 that isn't a blank line
+      if (bodyLine.length > 0 && !bodyLine.startsWith(' ') && !bodyLine.startsWith('\t') && bodyLine.trim() !== '') {
+        break;
+      }
+
+      const trimmed = bodyLine.trim();
+
+      // Parse __tablename__
+      const tnMatch = trimmed.match(/^__tablename__\s*=\s*['"](\w+)['"]/);
+      if (tnMatch) {
+        tableName = tnMatch[1];
+        isModel = true;
+        i++;
+        continue;
+      }
+
+      // Join multi-line statements within class body
+      let fullLine = trimmed;
+      if (fullLine) {
+        let openP = 0;
+        for (const ch of fullLine) {
+          if (ch === '(') openP++;
+          else if (ch === ')') openP--;
+        }
+        while (openP > 0 && i + 1 < lines.length) {
+          i++;
+          const nextLine = lines[i].trim();
+          fullLine += ' ' + nextLine;
+          for (const ch of nextLine) {
+            if (ch === '(') openP++;
+            else if (ch === ')') openP--;
+          }
+        }
+      }
+
+      // SA 1.x: name = Column(...)
+      const col1Match = fullLine.match(/^(\w+)\s*=\s*Column\s*\(/);
+      if (col1Match) {
+        const colName = col1Match[1];
+        const argsStr = getBalancedArgs(fullLine, 'Column');
+        if (argsStr) {
+          const colType = extractColumnType(argsStr);
+          const nullable = extractNullable(argsStr);
+          const primaryKey = extractPrimaryKey(argsStr);
+          columns.push({ name: colName, type: colType, nullable, primaryKey });
+          foreignKeys.push(...extractForeignKeys(colName, argsStr));
+        }
+        i++;
+        continue;
+      }
+
+      // SA 2.0: name: Mapped[type] = mapped_column(...)
+      const col2Match = fullLine.match(/^(\w+)\s*:\s*(Mapped\[.+?\])\s*=\s*mapped_column\s*\(/);
+      if (col2Match) {
+        const colName = col2Match[1];
+        const mappedAnnotation = col2Match[2];
+        const argsStr = getBalancedArgs(fullLine, 'mapped_column');
+        const mappedType = extractMappedType(mappedAnnotation);
+        const nullable = mappedType.startsWith('Optional') || extractNullable(argsStr || '');
+        const primaryKey = extractPrimaryKey(argsStr || '');
+        columns.push({ name: colName, type: mappedType, nullable, primaryKey });
+        if (argsStr) {
+          foreignKeys.push(...extractForeignKeys(colName, argsStr));
+        }
+        i++;
+        continue;
+      }
+
+      // relationship()
+      const relMatch = fullLine.match(/^(\w+)\s*(?::\s*[^=]+)?\s*=\s*relationship\s*\(/);
+      if (relMatch) {
+        const relName = relMatch[1];
+        const argsStr = getBalancedArgs(fullLine, 'relationship');
+        if (argsStr) {
+          const parsed = parseRelationship(argsStr);
+          if (parsed) {
+            relationships.push({
+              name: relName,
+              target: parsed.target,
+              back_populates: parsed.back_populates,
+            });
+          }
+        }
+        i++;
+        continue;
+      }
+
+      i++;
+    }
+
+    if (isModel) {
+      models.push({
+        className,
+        tableName,
+        columns,
+        relationships,
+        foreignKeys,
+        line: classLine,
+      });
+    }
+  }
+
+  return models;
+}