apiforge-analyzer 1.3.6 → 1.3.8

package/dist/cjs/frameworks/python.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * FastAPI / Flask / Django (+ DRF) analyzer
+ *
+ * Python apps can't be handed to analyze() as a JS object, so this runs the
+ * user's own interpreter (their venv, so their dependencies resolve), imports
+ * the app, and reads the framework's live route table — see
+ * python-introspect.ts. Nothing is injected into the user's code and no server
+ * is started. Returns the same Route[] as every other analyzer; enrichment and
+ * upload happen in index.ts / uploader.ts exactly as for Express or Fastify.
+ *
+ * The `npx apiforge` CLI instead works like its Node flow: it injects a snippet
+ * into the file returned in PythonAppCandidate.file and runs the user's own
+ * start command (see pythonFlow in cli.ts).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePython = analyzePython;
+exports.findPythonInterpreter = findPythonInterpreter;
+exports.findPythonApps = findPythonApps;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const python_introspect_js_1 = require("./python-introspect.js");
+const SKIP_DIRS = new Set([
+    '.git', '.venv', 'venv', 'env', '.env', 'node_modules', '__pycache__', 'site-packages',
+    '.tox', '.mypy_cache', '.pytest_cache', 'dist', 'build', 'migrations',
+]);
+/**
+ * Analyze a Python web app's routes
+ */
+async function analyzePython(options) {
+    let appDir = options.appDir || process.cwd();
+    let { app, factory, djangoSettings } = options;
+    // Fill in whatever the caller left out from the project layout.
+    if (options.framework === 'django' ? !app && !djangoSettings && !process.env.DJANGO_SETTINGS_MODULE : !app) {
+        const [candidate] = findPythonApps(options.framework, appDir);
+        if (!candidate) {
+            throw new Error(options.framework === 'django'
+                ? 'Django settings not found — pass djangoSettings (e.g. "mysite.settings")'
+                : `${options.framework} app not found — pass pythonApp (e.g. "main:app")`);
+        }
+        ;
+        ({ app, factory, djangoSettings, appDir } = candidate);
+    }
+    const pythonPath = options.pythonPath || findPythonInterpreter(appDir);
+    const stdout = await runPython(pythonPath, appDir, {
+        framework: options.framework, app, factory, djangoSettings, appDir,
+    }, options.timeoutMs ?? 60000);
+    const line = stdout.split(/\r?\n/).find(l => l.startsWith(python_introspect_js_1.ROUTES_MARKER));
+    if (!line)
+        throw new Error('Python analyzer produced no output');
+    return JSON.parse(line.slice(python_introspect_js_1.ROUTES_MARKER.length));
+}
+function runPython(pythonPath, cwd, opts, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(pythonPath, ['-'], {
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                APIFORGE_PY_OPTIONS: JSON.stringify(opts),
+                PYTHONIOENCODING: 'utf-8',
+                // Don't leave __pycache__ folders behind in the user's project.
+                PYTHONDONTWRITEBYTECODE: '1',
+            },
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => { stdout += chunk.toString('utf-8'); });
+        child.stderr.on('data', (chunk) => { stderr += chunk.toString('utf-8'); });
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`Python analyzer timed out after ${Math.round(timeoutMs / 1000)}s`));
+        }, timeoutMs);
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            reject(new Error(err.code === 'ENOENT'
+                ? `Python interpreter not found: "${pythonPath}" — activate your virtualenv or set APIFORGE_PYTHON`
+                : err.message));
+        });
+        child.on('close', code => {
+            clearTimeout(timer);
+            if (code === 0)
+                return resolve(stdout);
+            // The last traceback line is the actual error (ModuleNotFoundError: ..., etc.)
+            const lastLine = stderr.trim().split(/\r?\n/).pop() || `exited with code ${code}`;
+            reject(new Error(`Python analyzer failed: ${lastLine}`));
+        });
+        child.stdin.end(python_introspect_js_1.PYTHON_INTROSPECT_SCRIPT);
+    });
+}
+/**
+ * The interpreter that has the project's dependencies installed:
+ * APIFORGE_PYTHON → active virtualenv → a venv inside the project → system python.
+ */
+function findPythonInterpreter(projectDir = process.cwd()) {
+    if (process.env.APIFORGE_PYTHON)
+        return process.env.APIFORGE_PYTHON;
+    const inVenv = (venvDir) => process.platform === 'win32'
+        ? path.join(venvDir, 'Scripts', 'python.exe')
+        : path.join(venvDir, 'bin', 'python');
+    const candidates = [
+        process.env.VIRTUAL_ENV,
+        ...['.venv', 'venv', 'env'].map(dir => path.join(projectDir, dir)),
+    ].filter(Boolean).map(dir => inVenv(dir));
+    return candidates.find(p => fs.existsSync(p)) || (process.platform === 'win32' ? 'python' : 'python3');
+}
+/**
+ * Find where the app object (FastAPI/Flask) or settings module (Django) lives.
+ */
+function findPythonApps(framework, projectDir = process.cwd()) {
+    const files = listPythonFiles(projectDir, 3);
+    if (framework === 'django') {
+        const candidates = [];
+        for (const file of files.filter(f => path.basename(f) === 'manage.py')) {
+            const content = fs.readFileSync(file, 'utf-8');
+            const match = content.match(/DJANGO_SETTINGS_MODULE['"]\s*,\s*['"]([\w.]+)['"]/);
+            if (match) {
+                const appDir = path.dirname(file);
+                // The CLI injects into manage.py itself: every runserver goes through it, whereas
+                // wsgi.py is only loaded when settings.WSGI_APPLICATION points at it.
+                candidates.push({ label: `${match[1]}  (${path.relative(projectDir, file) || 'manage.py'})`, djangoSettings: match[1], appDir, file });
+            }
+        }
+        return candidates;
+    }
+    const ctor = framework === 'fastapi' ? 'FastAPI' : 'Flask';
+    const instanceRe = new RegExp(`^(\\w+)\\s*(?::\\s*\\w+\\s*)?=\\s*(?:\\w+\\.)?${ctor}\\(`, 'gm');
+    const candidates = [];
+    for (const file of files) {
+        const content = fs.readFileSync(file, 'utf-8');
+        if (!content.includes(ctor))
+            continue;
+        // src/ layout: import from inside src/ so the app's own absolute imports resolve
+        const rel = path.relative(projectDir, file).split(path.sep);
+        const appDir = rel[0] === 'src' ? path.join(projectDir, 'src') : projectDir;
+        if (rel[0] === 'src')
+            rel.shift();
+        const module = rel.join('.').replace(/\.py$/, '').replace(/\.__init__$/, '');
+        for (const match of content.matchAll(instanceRe)) {
+            candidates.push({ label: `${module}:${match[1]}`, app: `${module}:${match[1]}`, appDir, file });
+        }
+        if (framework === 'flask' && !content.match(instanceRe)) {
+            const factory = content.match(/^def\s+(create_app|make_app)\s*\(/m);
+            if (factory)
+                candidates.push({ label: `${module}:${factory[1]}()`, app: `${module}:${factory[1]}`, factory: true, appDir, file });
+        }
+    }
+    // Top-level entry files first: main.py / app.py beat a FastAPI() in some sub-module
+    return candidates.sort((a, b) => depth(a.app) - depth(b.app));
+}
+function depth(app) {
+    return (app || '').split(':')[0].split('.').length;
+}
+function listPythonFiles(dir, maxDepth, level = 0) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (level < maxDepth && !SKIP_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+                files.push(...listPythonFiles(full, maxDepth, level + 1));
+            }
+        }
+        else if (entry.isFile() && entry.name.endsWith('.py')) {
+            files.push(full);
+        }
+    }
+    return files;
+}

package/dist/cjs/index.js

@@ -3,7 +3,7 @@
  * APIForge Analyzer — main entry point (dual ESM/CJS)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectArchitectureType = exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzeFastify = exports.analyzeNestJS = exports.analyzeReactRouter = exports.analyzeVite = exports.analyzeNextApp = exports.analyzeNextPages = exports.analyzeExpress = void 0;
+exports.detectArchitectureType = exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzePython = exports.analyzeFastify = exports.analyzeNestJS = exports.analyzeReactRouter = exports.analyzeVite = exports.analyzeNextApp = exports.analyzeNextPages = exports.analyzeExpress = void 0;
 exports.analyze = analyze;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -21,6 +21,8 @@ const nestjs_js_1 = require("./frameworks/nestjs.js");
 Object.defineProperty(exports, "analyzeNestJS", { enumerable: true, get: function () { return nestjs_js_1.analyzeNestJS; } });
 const fastify_js_1 = require("./frameworks/fastify.js");
 Object.defineProperty(exports, "analyzeFastify", { enumerable: true, get: function () { return fastify_js_1.analyzeFastify; } });
+const python_js_1 = require("./frameworks/python.js");
+Object.defineProperty(exports, "analyzePython", { enumerable: true, get: function () { return python_js_1.analyzePython; } });
 const detect_js_1 = require("./detect.js");
 const export_js_1 = require("./export.js");
 const uploader_js_1 = require("./uploader.js");
@@ -178,6 +180,18 @@ async function analyze(app, options) {
             case 'react-router':
                 routes = await (0, react_router_js_1.analyzeReactRouter)(options.nextDir || 'src/routes.tsx');
                 break;
+            case 'fastapi':
+            case 'flask':
+            case 'django':
+                routes = await (0, python_js_1.analyzePython)({
+                    framework: framework,
+                    app: options.pythonApp,
+                    factory: options.pythonFactory,
+                    pythonPath: options.pythonPath,
+                    djangoSettings: options.djangoSettings,
+                    appDir: options.nextDir,
+                });
+                break;
             // No default: unsupported frameworks are rejected above, before this
             // try block, so a thrown error here isn't silently swallowed into `[]`.
         }
@@ -239,6 +253,7 @@ exports.default = {
     analyzeVite: vite_js_1.analyzeVite,
     analyzeReactRouter: react_router_js_1.analyzeReactRouter,
     analyzeNestJS: nestjs_js_1.analyzeNestJS,
+    analyzePython: python_js_1.analyzePython,
     exportToJSON: export_js_1.exportToJSON,
     uploadRoutes: uploader_js_1.uploadRoutes,
     detectFramework: detect_js_1.detectFramework,