project-librarian 0.2.0

package/dist/wiki-files.js

@@ -0,0 +1,289 @@
+"use strict";
+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.ignoredDirs = exports.standardWikiFiles = void 0;
+exports.walkMarkdownFiles = walkMarkdownFiles;
+exports.firstHeading = firstHeading;
+exports.compactSummary = compactSummary;
+exports.splitMarkdownRow = splitMarkdownRow;
+exports.parseMarkdownTableRows = parseMarkdownTableRows;
+exports.wikiMarkdownFiles = wikiMarkdownFiles;
+exports.wikiLinkForFile = wikiLinkForFile;
+exports.normalizeWikiLinkTarget = normalizeWikiLinkTarget;
+exports.extractWikiLinks = extractWikiLinks;
+exports.wikiTitleForFile = wikiTitleForFile;
+exports.metadataSummary = metadataSummary;
+exports.stripMarkedSection = stripMarkedSection;
+exports.extractMarkedSection = extractMarkedSection;
+exports.withPreservedMarkedSections = withPreservedMarkedSections;
+exports.hasGlossaryNeedSignal = hasGlossaryNeedSignal;
+exports.hasGlossaryTable = hasGlossaryTable;
+exports.canonicalBodyForLint = canonicalBodyForLint;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const workspace_1 = require("./workspace");
+exports.standardWikiFiles = new Set([
+    "AGENTS.md",
+    "wiki/AGENTS.md",
+    ".githooks/prepare-commit-msg",
+    ".githooks/wiki-commit-trailers.js",
+    ".codex/hooks.json",
+    ".codex/hooks/wiki-session-start.js",
+    ".claude/settings.json",
+    ".claude/hooks/wiki-session-start.js",
+    "wiki/README.md",
+    "wiki/startup.md",
+    "wiki/index.md",
+    "wiki/inbox/project-candidates.md",
+    "wiki/migration/inventory.md",
+    "wiki/migration/plan.md",
+    "wiki/migration/review.md",
+    "wiki/migration/verification.md",
+    "wiki/canonical/project-brief.md",
+    "wiki/canonical/glossary.md",
+    "wiki/canonical/open-questions.md",
+    "wiki/canonical/assumptions.md",
+    "wiki/canonical/risks.md",
+    "wiki/canonical/migration-inbox.md",
+    "wiki/decisions/README.md",
+    "wiki/decisions/log.md",
+    "wiki/decisions/recent.md",
+    "wiki/decisions/decision-pack-template.md",
+    "wiki/decisions/full-adr-template.md",
+    "wiki/decisions/migration-inbox.md",
+    "wiki/meta/operating-model.md",
+    "wiki/meta/decision-policy.md",
+    "wiki/meta/wiki-ops-v1-decisions.md",
+    "wiki/sources/karpathy-llm-wiki.md",
+    "wiki/sources/migration-inbox.md",
+    "tools/project-librarian/SKILL.md",
+    "tools/project-librarian/agents/openai.yaml",
+    "tools/project-librarian/dist/init-project-wiki.js",
+]);
+exports.ignoredDirs = new Set([".git", ".codex", ".claude", "node_modules", ".next", "dist", "build", "coverage", "vendor", "tmp", "temp"]);
+function walkMarkdownFiles(dir = workspace_1.root, acc = [], baseDir = workspace_1.root) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = (0, workspace_1.normalizePath)(path.relative(workspace_1.root, fullPath));
+        const basePath = (0, workspace_1.normalizePath)(path.relative(baseDir, fullPath));
+        if (!relativePath || relativePath.startsWith(".."))
+            continue;
+        if (entry.isDirectory()) {
+            if (exports.ignoredDirs.has(entry.name))
+                continue;
+            if (relativePath === "tools/project-librarian")
+                continue;
+            if (relativePath.startsWith("wiki/migration"))
+                continue;
+            walkMarkdownFiles(fullPath, acc, baseDir);
+        }
+        else if (entry.isFile() && /\.(md|mdx)$/i.test(entry.name) && !exports.standardWikiFiles.has(relativePath)) {
+            acc.push({ path: relativePath, basePath });
+        }
+    }
+    return acc.sort((a, b) => a.path.localeCompare(b.path));
+}
+function firstHeading(text, fallback) {
+    const heading = text.match(/^#{1,3}\s+(.+)$/m);
+    if (heading?.[1])
+        return heading[1].trim().replace(/\s+/g, " ");
+    return fallback.replace(/\.(md|mdx)$/i, "").split("/").pop() ?? fallback;
+}
+function compactSummary(text) {
+    return text
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/[#*_`>\-[\]()]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 180);
+}
+function splitMarkdownRow(line) {
+    const trimmed = line.trim();
+    const row = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+    const cells = [];
+    let current = "";
+    let escaped = false;
+    for (const char of row) {
+        if (escaped) {
+            current += char === "|" ? "|" : `\\${char}`;
+            escaped = false;
+        }
+        else if (char === "\\") {
+            escaped = true;
+        }
+        else if (char === "|") {
+            cells.push(current.trim());
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    if (escaped)
+        current += "\\";
+    cells.push(current.trim());
+    return cells;
+}
+function parseMarkdownTableRows(text, expectedColumns) {
+    return text
+        .split(/\r?\n/)
+        .filter((line) => /^\|.+\|$/.test(line.trim()))
+        .map(splitMarkdownRow)
+        .filter((cells) => cells.length >= expectedColumns)
+        .filter((cells) => !cells.every((cell) => /^-+$/.test(cell.replace(/\s/g, ""))))
+        .filter((cells) => !/^(source|legacy source|document)$/i.test(cells[0] ?? ""))
+        .filter((cells) => cells[0] !== "none");
+}
+function wikiMarkdownFiles() {
+    return (0, workspace_1.walkFilesUnder)("wiki", (file) => /\.(md|mdx)$/i.test(file) && file !== "wiki/AGENTS.md").sort();
+}
+function wikiLinkForFile(relativePath) {
+    return `[[${relativePath.replace(/^wiki\//, "").replace(/\.(md|mdx)$/i, "")}]]`;
+}
+function stripIgnoredMarkdownBlocks(text) {
+    return text
+        .replace(/```[\s\S]*?```/g, "")
+        .replace(/`[^`\n]*`/g, "");
+}
+function normalizeWikiLinkTarget(sourceFile, rawTarget, relativeToSource = false) {
+    let target = rawTarget
+        .trim()
+        .split("|", 1)[0] ?? "";
+    target = target.split("#", 1)[0]?.split("?", 1)[0]?.trim() ?? "";
+    if (!target || /^(https?:|mailto:|tel:)/i.test(target))
+        return "";
+    if (target.startsWith("/wiki/")) {
+        target = target.replace(/^\//, "");
+    }
+    else if (target.startsWith("/")) {
+        return "";
+    }
+    if (target.startsWith("./") || target.startsWith("../") || (relativeToSource && !target.startsWith("wiki/"))) {
+        const sourceDir = path.dirname(sourceFile);
+        target = (0, workspace_1.normalizePath)(path.normalize(path.join(sourceDir, target)));
+    }
+    else if (!target.startsWith("wiki/")) {
+        target = `wiki/${target}`;
+    }
+    if (!/\.(md|mdx)$/i.test(target))
+        target = `${target}.md`;
+    return (0, workspace_1.normalizePath)(target);
+}
+function markdownLinkTarget(rawTarget) {
+    const trimmed = rawTarget.trim();
+    if (trimmed.startsWith("<")) {
+        const end = trimmed.indexOf(">");
+        return end > 0 ? trimmed.slice(1, end).trim() : "";
+    }
+    return trimmed.split(/\s+/, 1)[0] ?? "";
+}
+function isMarkdownDocumentTarget(rawTarget) {
+    const target = rawTarget.split("#", 1)[0]?.split("?", 1)[0]?.trim() ?? "";
+    if (!target)
+        return false;
+    const ext = path.extname(target).toLowerCase();
+    return !ext || ext === ".md" || ext === ".mdx";
+}
+function extractWikiLinks(file, text) {
+    const body = stripIgnoredMarkdownBlocks((0, workspace_1.stripMetadataHeader)(text));
+    const links = [];
+    for (const match of body.matchAll(/\[\[([^\]\n]+)\]\]/g)) {
+        const target = match[1]?.trim() ?? "";
+        const normalizedTarget = normalizeWikiLinkTarget(file, target);
+        if (normalizedTarget)
+            links.push({ file, target, normalizedTarget, kind: "wikilink" });
+    }
+    for (const match of body.matchAll(/\[[^\]\n]*\]\(([^)\n]+)\)/g)) {
+        if (match.index && body[match.index - 1] === "!")
+            continue;
+        const target = markdownLinkTarget(match[1] ?? "");
+        if (!target || /^(https?:|mailto:|tel:|#)/i.test(target))
+            continue;
+        if (!isMarkdownDocumentTarget(target))
+            continue;
+        const normalizedTarget = normalizeWikiLinkTarget(file, target, true);
+        if (normalizedTarget.startsWith("wiki/"))
+            links.push({ file, target, normalizedTarget, kind: "markdown" });
+    }
+    return links;
+}
+function wikiTitleForFile(relativePath, text) {
+    return firstHeading((0, workspace_1.stripMetadataHeader)(text), relativePath);
+}
+function metadataSummary(relativePath, text) {
+    return {
+        status: (0, workspace_1.metadataValue)(text, "status") || "-",
+        scope: (0, workspace_1.metadataValue)(text, "scope") || "-",
+        budget: (0, workspace_1.metadataValue)(text, "read_budget") || "-",
+    };
+}
+function stripMarkedSection(text, startMarker, endMarker) {
+    const start = text.indexOf(startMarker);
+    const end = text.indexOf(endMarker);
+    if (start < 0 || end <= start)
+        return text;
+    return `${text.slice(0, start).trimEnd()}\n\n${text.slice(end + endMarker.length).trimStart()}`.trim() + "\n";
+}
+function extractMarkedSection(text, startMarker, endMarker) {
+    const start = text.indexOf(startMarker);
+    const end = text.indexOf(endMarker);
+    if (start < 0 || end <= start)
+        return "";
+    return text.slice(start, end + endMarker.length).trim();
+}
+function withPreservedMarkedSections(relativePath, base, markerPairs) {
+    if (!(0, workspace_1.exists)(relativePath))
+        return base;
+    const current = (0, workspace_1.read)(relativePath);
+    const preserved = markerPairs
+        .map(([startMarker, endMarker]) => extractMarkedSection(current, startMarker, endMarker))
+        .filter(Boolean)
+        .filter((section) => !base.includes(section));
+    if (preserved.length === 0)
+        return base;
+    return `${base.trimEnd()}\n\n${preserved.join("\n\n")}\n`;
+}
+function hasGlossaryNeedSignal(text) {
+    return /(^|\n)##\s+(Glossary|Terms|Roles|Entities|Data Model|State Model|Permissions|Events|용어|역할|엔티티|상태 모델|권한|이벤트)(\s|$)|`[^`]+`\s*(term|role|state|permission|event|entity|API|DB|UI|용어|역할|상태|권한|이벤트|엔티티)/i.test(text);
+}
+function hasGlossaryTable(text) {
+    const body = (0, workspace_1.stripMetadataHeader)(text);
+    return /\|\s*Term\s*\|\s*Definition\s*\|\s*Avoid\s*\|\s*Related Canonical Doc\s*\|\s*Status\s*\|/.test(body);
+}
+function canonicalBodyForLint() {
+    return (0, workspace_1.walkFilesUnder)("wiki/canonical", (file) => /\.(md|mdx)$/i.test(file) && file !== "wiki/canonical/glossary.md")
+        .map((file) => (0, workspace_1.stripMetadataHeader)((0, workspace_1.read)(file)))
+        .join("\n");
+}

package/dist/workspace.js

@@ -0,0 +1,212 @@
+"use strict";
+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.today = exports.root = void 0;
+exports.abs = abs;
+exports.exists = exists;
+exports.read = read;
+exports.write = write;
+exports.mkdirp = mkdirp;
+exports.writeManaged = writeManaged;
+exports.writeStarter = writeStarter;
+exports.upsertMarkedSection = upsertMarkedSection;
+exports.deleteIfGenerated = deleteIfGenerated;
+exports.parseJson = parseJson;
+exports.hasMetadataHeader = hasMetadataHeader;
+exports.metadataValue = metadataValue;
+exports.stripMetadataHeader = stripMetadataHeader;
+exports.normalizePath = normalizePath;
+exports.commandOk = commandOk;
+exports.isGitRepository = isGitRepository;
+exports.makeExecutable = makeExecutable;
+exports.walkFilesUnder = walkFilesUnder;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const childProcess = __importStar(require("node:child_process"));
+exports.root = process.cwd();
+exports.today = new Date().toISOString().slice(0, 10);
+function abs(relativePath) {
+    return path.join(exports.root, relativePath);
+}
+function exists(relativePath) {
+    return fs.existsSync(abs(relativePath));
+}
+function read(relativePath) {
+    return fs.readFileSync(abs(relativePath), "utf8");
+}
+function write(relativePath, content) {
+    const filePath = abs(relativePath);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+}
+function mkdirp(relativePath) {
+    fs.mkdirSync(abs(relativePath), { recursive: true });
+}
+function writeManaged(relativePath, content) {
+    const previous = exists(relativePath) ? read(relativePath) : "";
+    if (previous === content)
+        return "exists";
+    write(relativePath, content);
+    return previous ? "updated" : "created";
+}
+function writeStarter(relativePath, content) {
+    if (!exists(relativePath)) {
+        write(relativePath, content);
+        return "created";
+    }
+    const current = read(relativePath);
+    if (current === content)
+        return "exists";
+    if (hasMetadataHeader(current))
+        return "exists";
+    const generatedSignals = [
+        "This file is the current project-planning truth",
+        "This wiki keeps project planning knowledge",
+        "This page tracks unresolved project questions",
+        "# <Topic> v<N> Decisions",
+        "# ADR: <Title>",
+        "# Karpathy LLM Wiki",
+        "# Glossary",
+        "아직 제품/서비스 주제는 정해지지 않았다",
+    ];
+    if (!generatedSignals.some((signal) => current.includes(signal)))
+        return "manual-review";
+    write(relativePath, content);
+    return "updated";
+}
+function upsertMarkedSection(relativePath, startMarker, endMarker, section) {
+    if (!exists(relativePath)) {
+        write(relativePath, `${section.trim()}\n`);
+        return "created";
+    }
+    const current = read(relativePath);
+    const start = current.indexOf(startMarker);
+    const end = current.indexOf(endMarker);
+    if ((start >= 0) !== (end >= 0)) {
+        throw new Error(`${relativePath} has a malformed managed section: expected both ${startMarker} and ${endMarker}`);
+    }
+    if (start >= 0 && end > start) {
+        const next = `${current.slice(0, start).trimEnd()}\n\n${section.trim()}\n\n${current.slice(end + endMarker.length).trimStart()}`.trim() + "\n";
+        if (next === current)
+            return "exists";
+        write(relativePath, next);
+        return "updated";
+    }
+    if (start >= 0) {
+        throw new Error(`${relativePath} has a malformed managed section: ${endMarker} appears before ${startMarker}`);
+    }
+    write(relativePath, `${current.trimEnd()}\n\n${section.trim()}\n`);
+    return "updated";
+}
+function deleteIfGenerated(relativePath, sentinels) {
+    if (!exists(relativePath))
+        return "absent";
+    const current = read(relativePath);
+    if (!sentinels.some((sentinel) => current.includes(sentinel)))
+        return "manual-review";
+    fs.unlinkSync(abs(relativePath));
+    return "removed";
+}
+function parseJson(relativePath, fallback) {
+    if (!exists(relativePath))
+        return fallback;
+    try {
+        return JSON.parse(read(relativePath));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${relativePath} is not valid JSON: ${message}`);
+    }
+}
+function hasMetadataHeader(text) {
+    return /^---\n[\s\S]*?\n---\n/.test(text);
+}
+function metadataValue(text, key) {
+    const header = text.match(/^---\n([\s\S]*?)\n---\n/);
+    if (!header)
+        return "";
+    const headerBody = header[1] ?? "";
+    const match = headerBody.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    return match?.[1]?.trim() ?? "";
+}
+function stripMetadataHeader(text) {
+    return text.replace(/^---\n[\s\S]*?\n---\n/, "");
+}
+function normalizePath(filePath) {
+    return filePath.split(path.sep).join("/");
+}
+function commandOk(command, commandArgs, options = {}) {
+    try {
+        childProcess.execFileSync(command, commandArgs, { stdio: "ignore", ...options });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isGitRepository() {
+    try {
+        return childProcess.execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+            cwd: exports.root,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim() === "true";
+    }
+    catch {
+        return false;
+    }
+}
+function makeExecutable(relativePath) {
+    if (!exists(relativePath))
+        return;
+    const currentMode = fs.statSync(abs(relativePath)).mode;
+    fs.chmodSync(abs(relativePath), currentMode | 0o755);
+}
+function walkFilesUnder(relativePath, predicate, acc = []) {
+    const dirPath = abs(relativePath);
+    if (!fs.existsSync(dirPath))
+        return acc;
+    for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+        const fullPath = path.join(dirPath, entry.name);
+        const childRelative = normalizePath(path.relative(exports.root, fullPath));
+        if (entry.isDirectory()) {
+            walkFilesUnder(childRelative, predicate, acc);
+        }
+        else if (entry.isFile() && predicate(childRelative)) {
+            acc.push(childRelative);
+        }
+    }
+    return acc.sort();
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "project-librarian",
+  "version": "0.2.0",
+  "description": "Create and maintain compact project context for humans and LLM coding agents.",
+  "license": "MIT",
+  "type": "commonjs",
+  "keywords": [
+    "agents",
+    "claude-code",
+    "codex",
+    "llm",
+    "project-planning",
+    "wiki"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkjk1176/project-librarian.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kkjk1176/project-librarian/issues"
+  },
+  "homepage": "https://github.com/kkjk1176/project-librarian#readme",
+  "files": [
+    "agents/",
+    "dist/",
+    "LICENSE",
+    "README.md",
+    "README.ko.md",
+    "README.ja.md",
+    "README.zh.md",
+    "SKILL.md"
+  ],
+  "bin": {
+    "project-librarian": "dist/init-project-wiki.js"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "scripts": {
+    "benchmark": "node benchmarks/project-metrics.js",
+    "benchmark:baseline": "npm run build && node benchmarks/project-metrics.js --sample-repo benchmarks/samples/web-service --sample-repo benchmarks/samples/python-cli --sample-repo benchmarks/samples/mixed-monorepo --require-clean --save-baseline --markdown",
+    "benchmark:ci": "npm run benchmark:ci-smoke",
+    "benchmark:ci-smoke": "npm run build && node benchmarks/project-metrics.js --quick --runs 2 --warmup-runs 1 --sample-repo benchmarks/samples/web-service --sample-repo benchmarks/samples/python-cli --sample-repo benchmarks/samples/mixed-monorepo --out benchmarks/reports/ci-current.json --markdown benchmarks/reports/ci-current.md",
+    "benchmark:release": "npm run build && node benchmarks/project-metrics.js --sample-repo benchmarks/samples/web-service --sample-repo benchmarks/samples/python-cli --sample-repo benchmarks/samples/mixed-monorepo --fail-on-regression --require-clean --markdown",
+    "benchmark:trend": "node benchmarks/project-metrics.js --trend-markdown",
+    "build": "tsc && chmod +x dist/init-project-wiki.js",
+    "typecheck": "tsc --noEmit",
+    "unit": "node --test tests/unit/*.test.js",
+    "test": "npm run build && npm run typecheck && npm run unit && bash tests/smoke.sh",
+    "prepack": "npm run build"
+  },
+  "optionalDependencies": {
+    "@sengac/tree-sitter": "^0.25.15",
+    "@sengac/tree-sitter-c": "^0.25.15",
+    "@sengac/tree-sitter-c-sharp": "^0.25.15",
+    "@sengac/tree-sitter-cpp": "^0.25.15",
+    "@sengac/tree-sitter-go": "^0.25.15",
+    "@sengac/tree-sitter-java": "^0.25.15",
+    "@sengac/tree-sitter-javascript": "^0.25.15",
+    "@sengac/tree-sitter-kotlin": "^0.4.6",
+    "@sengac/tree-sitter-php": "^0.25.15",
+    "@sengac/tree-sitter-python": "^0.25.15",
+    "@sengac/tree-sitter-rust": "^0.25.15",
+    "@sengac/tree-sitter-swift": "^0.25.15",
+    "@sengac/tree-sitter-typescript": "^0.25.15"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.2",
+    "typescript": "^6.0.3"
+  }
+}