@vibecodetown/mcp-server 2.1.0

package/build/tools/vibe_pm/memory_sync.js

@@ -0,0 +1,134 @@
+// adapters/mcp-ts/src/tools/vibe_pm/memory_sync.ts
+// vibe_pm.memory_sync - Local Memory sync (incremental index update)
+import { runEngine } from "../../engine.js";
+import { safeJsonParse } from "../../cli.js";
+import { validateToolInput } from "../../security/input-validator.js";
+import { resolveProjectId } from "./context.js";
+import { MemorySyncOutputSchema } from "../../generated/memory_sync_output.js";
+const inFlight = new Map();
+function isOfflineMode() {
+    const v = (process.env.VIBECODE_OFFLINE ?? "").trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function defaultPersistDir() {
+    return ".vibe/chroma";
+}
+function inFlightKey(args) {
+    return `${args.project_id}::${args.docs_root}::${args.persist_dir}::${args.mode}::${args.force_full ? "1" : "0"}`;
+}
+/**
+ * vibe_pm.memory_sync - Local Memory sync
+ *
+ * Internal mapping:
+ *   → vibecoding-helper memory-sync --project-id ... --docs-root ... --mode ... --force-full ...
+ */
+export async function memorySync(input) {
+    const basePath = process.cwd();
+    validateToolInput({
+        project_id: input.project_id,
+        custom_input: input.docs_root,
+    });
+    const project_id = input.project_id ?? resolveProjectId(undefined, basePath);
+    const docsRoot = (input.docs_root ?? "docs").trim();
+    const persistDir = defaultPersistDir();
+    const mode = input.mode ?? "on_demand";
+    const forceFull = input.force_full ?? false;
+    const key = inFlightKey({
+        project_id,
+        docs_root: docsRoot,
+        persist_dir: persistDir,
+        mode,
+        force_full: forceFull,
+    });
+    const existing = inFlight.get(key);
+    if (existing)
+        return existing;
+    const promise = (async () => {
+        try {
+            const args = [
+                "memory-sync",
+                "--project-id",
+                project_id,
+                "--docs-root",
+                docsRoot,
+                "--mode",
+                mode,
+                "--persist-dir",
+                persistDir
+            ];
+            if (forceFull)
+                args.push("--force-full");
+            const startedAt = Date.now();
+            const { code, stdout, stderr } = await runEngine("vibecoding-helper", args, { timeoutMs: 300_000 });
+            const durationMs = Date.now() - startedAt;
+            if (code !== 0) {
+                return MemorySyncOutputSchema.parse({
+                    project_id,
+                    status: "ERROR",
+                    summary: "Local Memory 동기화에 실패했습니다.",
+                    docs_root: docsRoot,
+                    persist_dir: persistDir,
+                    collection: "vibe_docs",
+                    result: {
+                        scanned_files: 0,
+                        ingested_files: 0,
+                        updated_files: 0,
+                        skipped_files: 0,
+                        duration_ms: durationMs
+                    },
+                    offline_mode: isOfflineMode(),
+                    issues: [stderr?.trim() ? `engine_error: ${stderr.trim()}` : `engine_exit_code: ${code}`],
+                    next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+                });
+            }
+            const parsed = safeJsonParse(stdout);
+            if (!parsed.ok) {
+                return MemorySyncOutputSchema.parse({
+                    project_id,
+                    status: "ERROR",
+                    summary: "Local Memory 동기화 응답을 해석할 수 없습니다.",
+                    docs_root: docsRoot,
+                    persist_dir: persistDir,
+                    collection: "vibe_docs",
+                    result: {
+                        scanned_files: 0,
+                        ingested_files: 0,
+                        updated_files: 0,
+                        skipped_files: 0,
+                        duration_ms: durationMs
+                    },
+                    offline_mode: isOfflineMode(),
+                    issues: [`invalid_json: ${parsed.error}`],
+                    next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+                });
+            }
+            return MemorySyncOutputSchema.parse(parsed.value);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return MemorySyncOutputSchema.parse({
+                project_id,
+                status: "ERROR",
+                summary: "Local Memory 동기화 중 오류가 발생했습니다.",
+                docs_root: docsRoot,
+                persist_dir: persistDir,
+                collection: "vibe_docs",
+                result: {
+                    scanned_files: 0,
+                    ingested_files: 0,
+                    updated_files: 0,
+                    skipped_files: 0,
+                    duration_ms: 0
+                },
+                offline_mode: isOfflineMode(),
+                issues: [msg],
+                next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+            });
+        }
+    })();
+    inFlight.set(key, promise);
+    promise.finally(() => {
+        inFlight.delete(key);
+    });
+    return promise;
+}

package/build/tools/vibe_pm/modules/decision_snapshot.js

@@ -0,0 +1,29 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function loadDecisionSnapshot(specHighRunDir) {
+    const p = path.join(specHighRunDir, "decisions", "decision_cards.json");
+    if (!fs.existsSync(p))
+        return [];
+    try {
+        const raw = fs.readFileSync(p, "utf-8");
+        const doc = JSON.parse(raw);
+        const cards = doc.cards ?? [];
+        const resolved = cards.filter((c) => c.resolution?.status === "resolved" && c.resolution?.chosen);
+        return resolved
+            .map((c) => {
+            const chosen = c.resolution?.chosen ?? null;
+            const chosenLabel = c.options?.find((o) => o.id === chosen)?.label;
+            return {
+                decision_id: String(c.id ?? ""),
+                category: c.category,
+                question: c.question,
+                chosen: chosen ? String(chosen) : undefined,
+                chosen_label: chosenLabel,
+            };
+        })
+            .filter((x) => x.decision_id);
+    }
+    catch {
+        return [];
+    }
+}

package/build/tools/vibe_pm/modules/ensure.js

@@ -0,0 +1,100 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getSpecHighRunsDir } from "../context.js";
+import { detectRepoContext } from "./repo_context.js";
+import { loadDecisionSnapshot } from "./decision_snapshot.js";
+import { ensureResearchModuleV1 } from "./research_v1.js";
+import { generateSkillsModuleV1 } from "./skills_v1.js";
+import { generatePlanningModuleV1 } from "./planning_v1.js";
+function ensureDir(p) {
+    fs.mkdirSync(p, { recursive: true });
+}
+export function getWritableSpecHighRunDir(runId, basePath) {
+    const runsRoot = getSpecHighRunsDir(basePath);
+    const runDir = path.join(runsRoot, runId);
+    ensureDir(runDir);
+    return runDir;
+}
+export function writeProjectBriefSnapshot(specHighRunDir, projectBrief) {
+    const dir = path.join(specHighRunDir, "modules", "_inputs");
+    ensureDir(dir);
+    fs.writeFileSync(path.join(dir, "project_brief.txt"), projectBrief.trim() + "\n", "utf-8");
+}
+export function ensureModulesForWorkOrder(opts) {
+    const specHighRunDir = getWritableSpecHighRunDir(opts.runId, opts.basePath);
+    const repoContext = detectRepoContext(opts.basePath);
+    const decisionSnapshot = loadDecisionSnapshot(specHighRunDir);
+    if (opts.projectBrief) {
+        writeProjectBriefSnapshot(specHighRunDir, opts.projectBrief);
+    }
+    const research = ensureResearchModuleV1({
+        repoRoot: opts.basePath,
+        specHighRunDir,
+        repoContext,
+        decisionSnapshot,
+        projectBrief: opts.projectBrief,
+    });
+    const skills = generateSkillsModuleV1({ repoRoot: opts.basePath, specHighRunDir, repoContext });
+    const planning = generatePlanningModuleV1({
+        specHighRunDir,
+        goal: "implement",
+        repoContext,
+        skillFingerprint: skills.fingerprint,
+        decisionSnapshot,
+    });
+    return {
+        research: { version: "v1", fingerprint: research.fingerprint, path: research.path },
+        skills: { version: "v1", fingerprint: skills.fingerprint, path: skills.path },
+        planning: { version: "v1", fingerprint: planning.fingerprint, path: planning.path },
+        skill_bundle_prompt_path: skills.bundle_prompt_path,
+    };
+}
+export function ensureResearchForBriefing(opts) {
+    const specHighRunDir = getWritableSpecHighRunDir(opts.runId, opts.basePath);
+    const repoContext = detectRepoContext(opts.basePath);
+    writeProjectBriefSnapshot(specHighRunDir, opts.projectBrief);
+    const research = ensureResearchModuleV1({
+        repoRoot: opts.basePath,
+        specHighRunDir,
+        repoContext,
+        decisionSnapshot: [],
+        projectBrief: opts.projectBrief,
+    });
+    return { version: "v1", fingerprint: research.fingerprint, path: research.path };
+}
+export function ensurePlanningForRepair(opts) {
+    const specHighRunDir = getWritableSpecHighRunDir(opts.runId, opts.basePath);
+    const repoContext = detectRepoContext(opts.basePath);
+    const decisionSnapshot = loadDecisionSnapshot(specHighRunDir);
+    // Try to reuse existing skill fingerprint if present
+    const skillsPath = path.join(specHighRunDir, "modules", "skills", "v1", "selection.json");
+    let skillFingerprint = "SKL-unknown";
+    if (fs.existsSync(skillsPath)) {
+        try {
+            const doc = JSON.parse(fs.readFileSync(skillsPath, "utf-8"));
+            if (doc.fingerprint)
+                skillFingerprint = String(doc.fingerprint);
+        }
+        catch {
+            // ignore
+        }
+    }
+    const planning = generatePlanningModuleV1({
+        specHighRunDir,
+        goal: opts.goal ?? "repair",
+        repoContext,
+        skillFingerprint,
+        decisionSnapshot,
+    });
+    return { version: "v1", fingerprint: planning.fingerprint, path: planning.path };
+}
+export function readFileIfExists(p) {
+    try {
+        if (!fs.existsSync(p))
+            return null;
+        return fs.readFileSync(p, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}

package/build/tools/vibe_pm/modules/fingerprint.js

@@ -0,0 +1,30 @@
+import { createHash } from "node:crypto";
+function stableSerialize(value) {
+    if (value === null)
+        return "null";
+    const t = typeof value;
+    if (t === "string")
+        return JSON.stringify(value);
+    if (t === "number")
+        return Number.isFinite(value) ? String(value) : JSON.stringify(value);
+    if (t === "boolean")
+        return value ? "true" : "false";
+    if (Array.isArray(value))
+        return `[${value.map(stableSerialize).join(",")}]`;
+    if (t === "object") {
+        const obj = value;
+        const keys = Object.keys(obj).sort();
+        return `{${keys
+            .map((k) => `${JSON.stringify(k)}:${stableSerialize(obj[k])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(String(value));
+}
+export function sha256Hex(input) {
+    return createHash("sha256").update(input, "utf8").digest("hex");
+}
+export function fingerprintJson(prefix, input) {
+    const canonical = stableSerialize(input);
+    const hex = sha256Hex(canonical);
+    return `${prefix}-${hex.slice(0, 12)}`;
+}

package/build/tools/vibe_pm/modules/fix_dependencies.js

@@ -0,0 +1,394 @@
+// adapters/mcp-ts/src/tools/vibe_pm/modules/fix_dependencies.ts
+// Auto-fix module for dependency issues
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Fix dependency issues in the project
+ *
+ * 1. Detect project type (Node.js vs Python)
+ * 2. Extract imports from code
+ * 3. Parse dependency file
+ * 4. Calculate missing packages
+ * 5. Add missing packages to dependency file
+ */
+export async function fixDependencies(basePath) {
+    const fixed = [];
+    const errors = [];
+    try {
+        const checkResult = await checkDependencies(basePath);
+        if (checkResult.projectType === "unknown") {
+            return { fixed, errors: ["프로젝트 타입을 감지할 수 없습니다"] };
+        }
+        if (checkResult.missingPackages.length === 0) {
+            return { fixed, errors: [] };
+        }
+        if (!checkResult.dependencyFile) {
+            return { fixed, errors: ["의존성 파일을 찾을 수 없습니다"] };
+        }
+        // Fix missing dependencies
+        if (checkResult.projectType === "node") {
+            const fixedPackages = await fixNodeDependencies(checkResult.dependencyFile, checkResult.missingPackages);
+            for (const pkg of fixedPackages) {
+                fixed.push({
+                    type: "MISSING_DEPENDENCY",
+                    description: `누락된 패키지 '${pkg}'를 package.json에 추가했습니다`,
+                    file: checkResult.dependencyFile,
+                    status: "FIXED"
+                });
+            }
+        }
+        else if (checkResult.projectType === "python") {
+            const fixedPackages = await fixPythonDependencies(checkResult.dependencyFile, checkResult.missingPackages);
+            for (const pkg of fixedPackages) {
+                fixed.push({
+                    type: "MISSING_DEPENDENCY",
+                    description: `누락된 패키지 '${pkg}'를 requirements.txt에 추가했습니다`,
+                    file: checkResult.dependencyFile,
+                    status: "FIXED"
+                });
+            }
+        }
+    }
+    catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+    }
+    return { fixed, errors };
+}
+/**
+ * Check for missing dependencies without fixing
+ */
+export async function checkDependencies(basePath) {
+    const packageJsonPath = path.join(basePath, "package.json");
+    const requirementsPath = path.join(basePath, "requirements.txt");
+    // Detect project type
+    const hasPackageJson = fs.existsSync(packageJsonPath);
+    const hasRequirements = fs.existsSync(requirementsPath);
+    if (hasPackageJson) {
+        const imports = await extractNodeImports(basePath);
+        const declared = parsePackageJsonDeps(packageJsonPath);
+        const missing = calculateMissingNodePackages(imports, declared);
+        return {
+            projectType: "node",
+            missingPackages: missing,
+            dependencyFile: packageJsonPath
+        };
+    }
+    if (hasRequirements) {
+        const imports = await extractPythonImports(basePath);
+        const declared = parseRequirementsTxt(requirementsPath);
+        const missing = calculateMissingPythonPackages(imports, declared);
+        return {
+            projectType: "python",
+            missingPackages: missing,
+            dependencyFile: requirementsPath
+        };
+    }
+    return {
+        projectType: "unknown",
+        missingPackages: [],
+        dependencyFile: null
+    };
+}
+/**
+ * Extract Node.js imports from source files
+ */
+async function extractNodeImports(basePath) {
+    const imports = new Set();
+    // Patterns for import extraction
+    const importPatterns = [
+        /import\s+.*?\s+from\s+['"]([^'"./][^'"]*)['"]/g,
+        /import\s+['"]([^'"./][^'"]*)['"]/g,
+        /require\s*\(\s*['"]([^'"./][^'"]*)['"]\s*\)/g
+    ];
+    // Find all JS/TS files
+    const files = findSourceFiles(basePath, [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]);
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(file, "utf-8");
+            for (const pattern of importPatterns) {
+                let match;
+                while ((match = pattern.exec(content)) !== null) {
+                    const pkg = extractPackageName(match[1]);
+                    if (pkg && !isNodeBuiltin(pkg)) {
+                        imports.add(pkg);
+                    }
+                }
+                pattern.lastIndex = 0; // Reset regex state
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    return imports;
+}
+/**
+ * Extract Python imports from source files
+ */
+async function extractPythonImports(basePath) {
+    const imports = new Set();
+    // Patterns for import extraction
+    const importPatterns = [
+        /^import\s+(\w+)/gm,
+        /^from\s+(\w+)/gm
+    ];
+    // Find all Python files
+    const files = findSourceFiles(basePath, [".py"]);
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(file, "utf-8");
+            for (const pattern of importPatterns) {
+                let match;
+                while ((match = pattern.exec(content)) !== null) {
+                    const pkg = match[1];
+                    if (pkg && !isPythonBuiltin(pkg)) {
+                        imports.add(pkg);
+                    }
+                }
+                pattern.lastIndex = 0;
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    return imports;
+}
+/**
+ * Find source files recursively
+ */
+function findSourceFiles(basePath, extensions) {
+    const files = [];
+    const ignoreDirs = ["node_modules", ".git", "__pycache__", ".venv", "venv", "dist", "build"];
+    function walk(dir) {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!ignoreDirs.includes(entry.name) && !entry.name.startsWith(".")) {
+                        walk(fullPath);
+                    }
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name);
+                    if (extensions.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip directories that can't be read
+        }
+    }
+    walk(basePath);
+    return files;
+}
+/**
+ * Extract package name from import path
+ * e.g., "@types/node" -> "@types/node", "lodash/fp" -> "lodash"
+ */
+function extractPackageName(importPath) {
+    if (!importPath)
+        return null;
+    // Handle scoped packages (@org/package)
+    if (importPath.startsWith("@")) {
+        const parts = importPath.split("/");
+        if (parts.length >= 2) {
+            return `${parts[0]}/${parts[1]}`;
+        }
+        return null;
+    }
+    // Handle regular packages
+    return importPath.split("/")[0];
+}
+/**
+ * Parse package.json dependencies
+ */
+function parsePackageJsonDeps(packageJsonPath) {
+    const deps = new Set();
+    try {
+        const content = fs.readFileSync(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(content);
+        if (pkg.dependencies) {
+            for (const dep of Object.keys(pkg.dependencies)) {
+                deps.add(dep);
+            }
+        }
+        if (pkg.devDependencies) {
+            for (const dep of Object.keys(pkg.devDependencies)) {
+                deps.add(dep);
+            }
+        }
+        if (pkg.peerDependencies) {
+            for (const dep of Object.keys(pkg.peerDependencies)) {
+                deps.add(dep);
+            }
+        }
+    }
+    catch {
+        // Return empty set on error
+    }
+    return deps;
+}
+/**
+ * Parse requirements.txt dependencies
+ */
+function parseRequirementsTxt(requirementsPath) {
+    const deps = new Set();
+    try {
+        const content = fs.readFileSync(requirementsPath, "utf-8");
+        const lines = content.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) {
+                continue;
+            }
+            // Extract package name (before version specifier)
+            const match = trimmed.match(/^([a-zA-Z0-9_-]+)/);
+            if (match) {
+                deps.add(match[1].toLowerCase());
+            }
+        }
+    }
+    catch {
+        // Return empty set on error
+    }
+    return deps;
+}
+/**
+ * Calculate missing Node.js packages
+ */
+function calculateMissingNodePackages(imports, declared) {
+    const missing = [];
+    for (const pkg of imports) {
+        if (!declared.has(pkg)) {
+            missing.push(pkg);
+        }
+    }
+    return missing;
+}
+/**
+ * Calculate missing Python packages
+ */
+function calculateMissingPythonPackages(imports, declared) {
+    const missing = [];
+    for (const pkg of imports) {
+        const normalized = pkg.toLowerCase();
+        if (!declared.has(normalized)) {
+            missing.push(normalized);
+        }
+    }
+    return missing;
+}
+/**
+ * Fix Node.js dependencies by adding to package.json
+ */
+async function fixNodeDependencies(packageJsonPath, missing) {
+    const fixed = [];
+    try {
+        const content = fs.readFileSync(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(content);
+        if (!pkg.dependencies) {
+            pkg.dependencies = {};
+        }
+        for (const pkgName of missing) {
+            // Add with "*" version (user should run npm install to get proper version)
+            pkg.dependencies[pkgName] = "*";
+            fixed.push(pkgName);
+        }
+        // Sort dependencies alphabetically
+        pkg.dependencies = Object.fromEntries(Object.entries(pkg.dependencies).sort(([a], [b]) => a.localeCompare(b)));
+        fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+    }
+    catch {
+        // Return what we fixed so far
+    }
+    return fixed;
+}
+/**
+ * Fix Python dependencies by adding to requirements.txt
+ */
+async function fixPythonDependencies(requirementsPath, missing) {
+    const fixed = [];
+    try {
+        let content = "";
+        if (fs.existsSync(requirementsPath)) {
+            content = fs.readFileSync(requirementsPath, "utf-8");
+            if (!content.endsWith("\n")) {
+                content += "\n";
+            }
+        }
+        for (const pkg of missing) {
+            content += `${pkg}\n`;
+            fixed.push(pkg);
+        }
+        fs.writeFileSync(requirementsPath, content);
+    }
+    catch {
+        // Return what we fixed so far
+    }
+    return fixed;
+}
+/**
+ * Check if package is a Node.js builtin module
+ */
+function isNodeBuiltin(pkg) {
+    const builtins = new Set([
+        "assert", "buffer", "child_process", "cluster", "console", "constants",
+        "crypto", "dgram", "dns", "domain", "events", "fs", "http", "https",
+        "module", "net", "os", "path", "perf_hooks", "process", "punycode",
+        "querystring", "readline", "repl", "stream", "string_decoder", "sys",
+        "timers", "tls", "tty", "url", "util", "v8", "vm", "wasi", "worker_threads", "zlib",
+        // Node.js built-in module prefixes
+        "node:assert", "node:buffer", "node:child_process", "node:cluster",
+        "node:console", "node:constants", "node:crypto", "node:dgram",
+        "node:dns", "node:domain", "node:events", "node:fs", "node:http",
+        "node:https", "node:module", "node:net", "node:os", "node:path",
+        "node:perf_hooks", "node:process", "node:punycode", "node:querystring",
+        "node:readline", "node:repl", "node:stream", "node:string_decoder",
+        "node:sys", "node:timers", "node:tls", "node:tty", "node:url",
+        "node:util", "node:v8", "node:vm", "node:wasi", "node:worker_threads", "node:zlib"
+    ]);
+    return builtins.has(pkg) || pkg.startsWith("node:");
+}
+/**
+ * Check if package is a Python builtin module
+ */
+function isPythonBuiltin(pkg) {
+    const builtins = new Set([
+        "abc", "aifc", "argparse", "array", "ast", "asynchat", "asyncio",
+        "asyncore", "atexit", "audioop", "base64", "bdb", "binascii", "binhex",
+        "bisect", "builtins", "bz2", "calendar", "cgi", "cgitb", "chunk",
+        "cmath", "cmd", "code", "codecs", "codeop", "collections", "colorsys",
+        "compileall", "concurrent", "configparser", "contextlib", "contextvars",
+        "copy", "copyreg", "cProfile", "crypt", "csv", "ctypes", "curses",
+        "dataclasses", "datetime", "dbm", "decimal", "difflib", "dis",
+        "distutils", "doctest", "email", "encodings", "enum", "errno",
+        "faulthandler", "fcntl", "filecmp", "fileinput", "fnmatch", "fractions",
+        "ftplib", "functools", "gc", "getopt", "getpass", "gettext", "glob",
+        "graphlib", "grp", "gzip", "hashlib", "heapq", "hmac", "html", "http",
+        "idlelib", "imaplib", "imghdr", "imp", "importlib", "inspect", "io",
+        "ipaddress", "itertools", "json", "keyword", "lib2to3", "linecache",
+        "locale", "logging", "lzma", "mailbox", "mailcap", "marshal", "math",
+        "mimetypes", "mmap", "modulefinder", "multiprocessing", "netrc", "nis",
+        "nntplib", "numbers", "operator", "optparse", "os", "ossaudiodev",
+        "pathlib", "pdb", "pickle", "pickletools", "pipes", "pkgutil", "platform",
+        "plistlib", "poplib", "posix", "posixpath", "pprint", "profile", "pstats",
+        "pty", "pwd", "py_compile", "pyclbr", "pydoc", "queue", "quopri",
+        "random", "re", "readline", "reprlib", "resource", "rlcompleter",
+        "runpy", "sched", "secrets", "select", "selectors", "shelve", "shlex",
+        "shutil", "signal", "site", "smtpd", "smtplib", "sndhdr", "socket",
+        "socketserver", "spwd", "sqlite3", "ssl", "stat", "statistics", "string",
+        "stringprep", "struct", "subprocess", "sunau", "symtable", "sys",
+        "sysconfig", "syslog", "tabnanny", "tarfile", "telnetlib", "tempfile",
+        "termios", "test", "textwrap", "threading", "time", "timeit", "tkinter",
+        "token", "tokenize", "trace", "traceback", "tracemalloc", "tty", "turtle",
+        "turtledemo", "types", "typing", "unicodedata", "unittest", "urllib",
+        "uu", "uuid", "venv", "warnings", "wave", "weakref", "webbrowser",
+        "winreg", "winsound", "wsgiref", "xdrlib", "xml", "xmlrpc", "zipapp",
+        "zipfile", "zipimport", "zlib", "_thread"
+    ]);
+    return builtins.has(pkg.toLowerCase());
+}