@openvcs/git-plugin 0.1.0

package/bin/plugin-request-handler.js

@@ -0,0 +1,336 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+import { VcsDelegateBase, pluginError, } from '@openvcs/sdk/runtime';
+import { asNumber, asRecord, asString, asStringArray, asTrimmedString, } from './plugin-helpers.js';
+import { GitCommand } from './git.js';
+/** Implements the Git-backed `vcs.*` delegate surface for the SDK runtime. */
+export class GitVcsDelegates extends VcsDelegateBase {
+    /** Returns the required repository worktree path for a session id. */
+    requireSessionPath(sessionId) {
+        return this.deps.requireSession(sessionId).path;
+    }
+    /** Returns a Git command helper bound to a required session. */
+    requireGit(sessionId) {
+        const cwd = this.requireSessionPath(sessionId);
+        return this.deps.createGitCommand(cwd);
+    }
+    getCaps(_params, _context) {
+        return {
+            commits: true,
+            branches: true,
+            tags: true,
+            staging: true,
+            push_pull: true,
+            fast_forward: true,
+        };
+    }
+    open(params, _context) {
+        const repoPath = asTrimmedString(params.path);
+        if (!repoPath) {
+            throw pluginError('vcs-open-invalid-path', 'path is required');
+        }
+        const git = this.deps.createGitCommand(repoPath);
+        git.runChecked(['rev-parse', '--git-dir'], 'vcs-open-not-repository');
+        const sessionId = this.deps.allocateSession({ path: repoPath });
+        return { session_id: sessionId };
+    }
+    close(params, _context) {
+        this.deps.closeSession(params.session_id);
+        return null;
+    }
+    cloneRepo(params, context) {
+        const url = asTrimmedString(params.url);
+        const destination = asTrimmedString(params.dest);
+        if (!url || !destination) {
+            throw pluginError('vcs-clone-invalid-args', 'url and dest are required');
+        }
+        const git = this.deps.createGitCommand(process.cwd());
+        const output = git.runChecked(['clone', url, destination], 'vcs-clone-failed');
+        const lines = `${output.stdout}\n${output.stderr}`
+            .split(/\r?\n/g)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        for (const line of lines) {
+            context.host.info(line);
+        }
+        return null;
+    }
+    getWorkdir(params, _context) {
+        return this.requireSessionPath(params.session_id);
+    }
+    getCurrentBranch(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const branch = git.currentBranch();
+        return branch === 'HEAD' ? null : branch;
+    }
+    listBranches(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const raw = git.runChecked([
+            'for-each-ref',
+            '--format=%(refname:short)\t%(refname)\t%(HEAD)',
+            'refs/heads',
+            'refs/remotes',
+        ], 'vcs-list-branches-failed');
+        return raw.stdout
+            .split(/\r?\n/g)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+            const [name = '', fullRef = '', headMark = ''] = line.split('\t');
+            const isRemote = fullRef.startsWith('refs/remotes/');
+            const remote = isRemote ? name.split('/')[0] ?? null : null;
+            const kind = isRemote
+                ? { type: 'Remote', remote }
+                : { type: 'Local' };
+            return {
+                name,
+                full_ref: fullRef,
+                kind,
+                current: headMark === '*',
+            };
+        });
+    }
+    listLocalBranches(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const raw = git.runChecked(['for-each-ref', '--format=%(refname:short)', 'refs/heads/'], 'vcs-list-branches-failed');
+        return raw.stdout
+            .split('\n')
+            .map((branch) => branch.trim())
+            .filter(Boolean);
+    }
+    createBranch(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.createBranch(asTrimmedString(params.name));
+        return null;
+    }
+    checkoutBranch(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.checkoutBranch(asTrimmedString(params.name));
+        return null;
+    }
+    ensureRemote(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const name = asTrimmedString(params.name);
+        const url = asTrimmedString(params.url);
+        if (!name || !url) {
+            throw pluginError('vcs-remote-invalid-args', 'name and url are required');
+        }
+        git.ensureRemote(name, url);
+        return null;
+    }
+    listRemotes(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const result = git.listRemotes();
+        return result.remotes.map((remote) => ({
+            name: remote.name,
+            url: remote.fetch || remote.push,
+        }));
+    }
+    removeRemote(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.removeRemote(asTrimmedString(params.name));
+        return null;
+    }
+    fetch(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const options = asRecord(params.opts);
+        git.fetch({
+            remote: asTrimmedString(params.remote) || undefined,
+            refspec: asTrimmedString(params.refspec) || undefined,
+            opts: { prune: options.prune === true },
+        });
+        return null;
+    }
+    push(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.push({
+            remote: asTrimmedString(params.remote) || undefined,
+            refspec: asTrimmedString(params.refspec) || undefined,
+        });
+        return null;
+    }
+    pullFfOnly(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.pull({
+            remote: asTrimmedString(params.remote) || undefined,
+            branch: asTrimmedString(params.branch) || undefined,
+        });
+        return null;
+    }
+    commit(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const result = git.runChecked(['rev-parse', 'HEAD'], 'git-commit-failed');
+        git.commit(asTrimmedString(params.message));
+        return result.stdout.trim();
+    }
+    commitIndex(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const result = git.runChecked(['rev-parse', 'HEAD'], 'git-commit-failed');
+        git.commitIndex(asTrimmedString(params.message), asTrimmedString(params.name), asTrimmedString(params.email), asStringArray(params.paths));
+        return result.stdout.trim();
+    }
+    getStatusSummary(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.status().summary;
+    }
+    getStatusPayload(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.status().payload;
+    }
+    listCommits(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const query = asRecord(params.query);
+        const result = git.listCommits({
+            branch: asTrimmedString(query.rev) || undefined,
+            skip: asNumber(query.skip, 0) || undefined,
+            limit: asNumber(query.limit, 0),
+            topo_order: query.topo_order ?? undefined,
+            include_merges: query.include_merges ?? undefined,
+            author_contains: asTrimmedString(query.author_contains) || undefined,
+            since_utc: asTrimmedString(query.since_utc) || undefined,
+            until_utc: asTrimmedString(query.until_utc) || undefined,
+            path: asTrimmedString(query.path) || undefined,
+        });
+        return result.commits;
+    }
+    diffFile(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.diffFile(asTrimmedString(params.path)).split('\n');
+    }
+    diffCommit(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.diffCommit(asTrimmedString(params.rev)).split('\n');
+    }
+    getConflictDetails(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.getConflictDetails(asTrimmedString(params.path));
+    }
+    checkoutConflictSide(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const side = asTrimmedString(params.side);
+        if (side !== 'ours' && side !== 'theirs') {
+            throw pluginError('vcs-invalid-side', 'side must be "ours" or "theirs"');
+        }
+        git.checkoutConflictSide(asTrimmedString(params.path), side);
+        return null;
+    }
+    writeMergeResult(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const content = Buffer.from(asTrimmedString(params.content_b64), 'base64').toString('utf8');
+        git.writeMergeResult(asTrimmedString(params.path), content);
+        return null;
+    }
+    stagePatch(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.stagePatch(asString(params.patch));
+        return null;
+    }
+    discardPaths(params, _context) {
+        const git = this.requireGit(params.session_id);
+        const paths = asStringArray(params.paths);
+        if (paths.length === 0) {
+            return null;
+        }
+        git.runChecked(['checkout', '--', ...paths], 'git-discard-paths-failed');
+        return null;
+    }
+    applyReversePatch(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.applyReversePatch(asString(params.patch));
+        return null;
+    }
+    deleteBranch(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.deleteBranch(asTrimmedString(params.name));
+        return null;
+    }
+    renameBranch(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.renameBranch(asTrimmedString(params.old), asTrimmedString(params.new));
+        return null;
+    }
+    mergeIntoCurrent(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.mergeIntoCurrent(asTrimmedString(params.name));
+        return null;
+    }
+    mergeAbort(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.mergeAbort();
+        return null;
+    }
+    mergeContinue(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.mergeContinue(asTrimmedString(params.message) || undefined);
+        return null;
+    }
+    isMergeInProgress(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.isMergeInProgress();
+    }
+    setBranchUpstream(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.setBranchUpstream(asTrimmedString(params.branch), asTrimmedString(params.upstream));
+        return null;
+    }
+    getBranchUpstream(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.getBranchUpstream(asTrimmedString(params.branch));
+    }
+    hardResetHead(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.hardResetHead(params.ref);
+        return null;
+    }
+    resetSoftTo(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.resetSoftTo(asTrimmedString(params.rev));
+        return null;
+    }
+    getIdentity(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.getIdentity();
+    }
+    setIdentityLocal(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.setIdentityLocal(asTrimmedString(params.name), asTrimmedString(params.email));
+        return null;
+    }
+    listStashes(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.listStashes();
+    }
+    stashPush(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.stashPush(asTrimmedString(params.message) || undefined, params.include_untracked);
+    }
+    stashApply(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.stashApply(asString(params.selector));
+        return null;
+    }
+    stashPop(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.stashPop(asString(params.selector));
+        return null;
+    }
+    stashDrop(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.stashDrop(asString(params.selector));
+        return null;
+    }
+    stashShow(params, _context) {
+        const git = this.requireGit(params.session_id);
+        return git.stashShow(asString(params.selector));
+    }
+    cherryPick(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.cherryPick(asTrimmedString(params.commit));
+        return null;
+    }
+    revertCommit(params, _context) {
+        const git = this.requireGit(params.session_id);
+        git.revertCommit(asTrimmedString(params.commit), params.no_edit);
+        return null;
+    }
+}

package/bin/plugin-runtime.js

@@ -0,0 +1,38 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+import { pluginError } from '@openvcs/sdk/runtime';
+import { asString } from './plugin-helpers.js';
+/** Stores the next session id allocated for `vcs.open`. Allocated once per plugin runtime instance
+ * and persists for the lifetime of the process. Session IDs are opaque integers assigned
+ * sequentially starting from 1. */
+let nextSessionId = 1;
+/** Stores all active repository sessions keyed by session id. */
+const sessions = new Map();
+/** Allocates a new repository session and returns its generated id. */
+export function allocateSession(session) {
+    const sessionId = String(nextSessionId);
+    nextSessionId += 1;
+    sessions.set(sessionId, session);
+    return sessionId;
+}
+/** Removes an existing repository session. */
+export function closeSession(sessionId) {
+    const key = asString(sessionId);
+    if (!sessions.has(key)) {
+        throw pluginError('vcs-invalid-session', `session '${key}' not found`);
+    }
+    sessions.delete(key);
+}
+/** Resets all session state. Useful for testing to ensure clean state between test runs. */
+export function resetSessions() {
+    nextSessionId = 1;
+    sessions.clear();
+}
+/** Resolves a required session or throws a host-facing plugin error. */
+export function requireSession(sessionId) {
+    const session = sessions.get(asString(sessionId));
+    if (!session) {
+        throw pluginError('vcs-invalid-session', `unknown session '${asString(sessionId)}'`);
+    }
+    return session;
+}

package/bin/plugin-types.js

@@ -0,0 +1,3 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+export {};

package/bin/plugin.js

@@ -0,0 +1,53 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+import { getOrCreateMenu, registerAction, invoke } from '@openvcs/sdk/runtime';
+import { GitVcsDelegates, } from './plugin-request-handler.js';
+import { allocateSession, closeSession, requireSession, } from './plugin-runtime.js';
+import { registerSubmoduleToolkit } from './submodules.js';
+import { GitCommand } from './git.js';
+/** Creates a GitCommand instance for a given repository path. */
+function createGitCommand(cwd) {
+    return new GitCommand(cwd);
+}
+/** Returns the runtime services passed to the Git VCS delegate class. */
+function createGitRuntimeDependencies() {
+    return {
+        allocateSession,
+        closeSession,
+        requireSession,
+        createGitCommand,
+    };
+}
+/** Registers the Git plugin with the OpenVCS SDK runtime.
+ *
+ * Provides Git runtime options up front and defers `vcs.*` delegate registration
+ * until `OnPluginStart()` validates the local Git installation. */
+export const PluginDefinition = {
+    logTarget: 'openvcs.git.plugin',
+};
+/** Validates Git installation and version at plugin startup.
+ *
+ * Runs before the runtime begins processing requests. Throws if Git is not
+ * installed or version is below 2.20.
+ * @throws Error if Git is not available or version is unsupported */
+export function OnPluginStart() {
+    const git = new GitCommand(process.cwd());
+    const { major, minor } = git.version();
+    if (major < 2 || (major === 2 && minor < 20)) {
+        throw new Error(`Git 2.20+ required, found ${major}.${minor}`);
+    }
+    const delegates = new GitVcsDelegates(createGitRuntimeDependencies());
+    PluginDefinition.vcs = delegates.toDelegates();
+    const repoMenu = getOrCreateMenu('repository', 'Repository');
+    if (repoMenu) {
+        repoMenu.addItem({ label: 'Edit .gitignore', action: 'repo-edit-gitignore' });
+        repoMenu.addItem({ label: 'Edit .gitattributes', action: 'repo-edit-gitattributes' });
+    }
+    registerSubmoduleToolkit();
+    registerAction('repo-edit-gitignore', async () => {
+        await invoke('open_repo_dotfile', { name: '.gitignore' });
+    });
+    registerAction('repo-edit-gitattributes', async () => {
+        await invoke('open_repo_dotfile', { name: '.gitattributes' });
+    });
+}

package/bin/submodules.js

@@ -0,0 +1,190 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+import { getOrCreateMenu, registerAction, ModalBuilder } from '@openvcs/sdk/runtime';
+import { GitCommand } from './git.js';
+/** Returns a Git command bound to the current process working directory. */
+function createGitCommand() {
+    return new GitCommand(process.cwd());
+}
+/** Coerces an unknown action payload into a plain record. */
+function asPayload(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+/** Returns one trimmed string field from an action payload. */
+function payloadString(payload, key) {
+    return String(payload[key] ?? '').trim();
+}
+/** Builds one modal row for a submodule entry. */
+function buildSubmoduleRow(entry) {
+    const metaBits = [entry.commit ? `commit ${entry.commit}` : '', entry.branch ? `branch ${entry.branch}` : '']
+        .map((part) => String(part || '').trim())
+        .filter(Boolean);
+    const description = [entry.url, metaBits.join(' · ')]
+        .map((part) => String(part || '').trim())
+        .filter(Boolean)
+        .join(' · ');
+    return {
+        id: entry.path,
+        title: entry.path,
+        status: entry.state,
+        meta: entry.name,
+        description,
+        actions: [
+            { type: 'button', id: 'submodules-update', content: 'Update', payload: { path: entry.path } },
+            { type: 'button', id: 'submodules-sync', content: 'Sync', payload: { path: entry.path } },
+            {
+                type: 'button',
+                id: 'submodules-remove-request',
+                content: 'Remove',
+                variant: 'danger',
+                payload: { path: entry.path, name: entry.name },
+            },
+        ],
+    };
+}
+/** Builds and opens the submodule manager modal. */
+async function openSubmodulesModal() {
+    const git = createGitCommand();
+    const entries = git.listSubmodules();
+    console.log('Git submodules: building modal', { count: entries.length });
+    const modal = new ModalBuilder('Manage Submodules')
+        .text('Review, add, update, sync, and remove submodules without leaving Git.')
+        .separator()
+        .input('url', 'Submodule URL', {
+        kind: 'url',
+        placeholder: 'https://example.com/repo.git',
+    })
+        .input('path', 'Submodule Path', {
+        placeholder: 'libs/example',
+    })
+        .input('name', 'Submodule Name', {
+        placeholder: 'example',
+    })
+        .input('branch', 'Branch (optional)', {
+        placeholder: 'main',
+    })
+        .button('submodules-add', 'Add Submodule', {
+        variant: 'primary',
+        align: 'centered',
+    })
+        .button('repo-submodules', 'Refresh', {
+        align: 'centered',
+    })
+        .button('submodules-update-all', 'Update All (Recursive)', {
+        align: 'centered',
+    })
+        .button('submodules-sync-all', 'Sync All', {
+        align: 'centered',
+    })
+        .separator()
+        .list('submodules', {
+        label: 'Submodules',
+        emptyText: 'This repository has no submodules yet.',
+        items: entries.map((entry) => buildSubmoduleRow(entry)),
+    });
+    return modal.open();
+}
+/** Builds and opens the remove confirmation modal for one submodule. */
+async function openRemoveConfirmationModal(path, name) {
+    const submodulePath = String(path || '').trim();
+    if (!submodulePath)
+        return;
+    console.log('Git submodules: building remove confirmation', { path: submodulePath, name });
+    const modal = new ModalBuilder('Confirm Submodule Removal')
+        .text(`Remove the submodule at ${submodulePath}? This will deinitialize the submodule, remove it from the index, and delete its working tree entry.`)
+        .button('repo-submodules', 'Back', {
+        align: 'centered',
+    })
+        .button('submodules-remove-confirm', 'Remove Submodule', {
+        variant: 'danger',
+        align: 'centered',
+        payload: { path: submodulePath, name: String(name || '').trim() || undefined },
+    });
+    return modal.open();
+}
+/** Removes one submodule and refreshes the toolkit modal. */
+async function removeSubmodule(payload) {
+    const path = payloadString(payload, 'path');
+    if (!path)
+        return;
+    const git = createGitCommand();
+    git.removeSubmodule(path);
+    await openSubmodulesModal();
+}
+/** Adds one submodule and refreshes the toolkit modal. */
+async function addSubmodule(payload) {
+    const url = payloadString(payload, 'url');
+    const path = payloadString(payload, 'path');
+    const name = payloadString(payload, 'name');
+    const branch = payloadString(payload, 'branch');
+    if (!url || !path) {
+        throw new Error('Submodule URL and path are required');
+    }
+    const git = createGitCommand();
+    git.addSubmodule(url, path, name || undefined, branch || undefined);
+    await openSubmodulesModal();
+}
+/** Updates one submodule and refreshes the toolkit modal. */
+async function updateSubmodule(payload) {
+    const path = payloadString(payload, 'path');
+    if (!path)
+        return;
+    const git = createGitCommand();
+    git.updateSubmodule(path);
+    await openSubmodulesModal();
+}
+/** Syncs one submodule and refreshes the toolkit modal. */
+async function syncSubmodule(payload) {
+    const path = payloadString(payload, 'path');
+    if (!path)
+        return;
+    const git = createGitCommand();
+    git.syncSubmodule(path);
+    await openSubmodulesModal();
+}
+/** Updates all submodules recursively and refreshes the toolkit modal. */
+async function updateAllSubmodules() {
+    const git = createGitCommand();
+    git.updateAllSubmodules();
+    await openSubmodulesModal();
+}
+/** Syncs all submodules recursively and refreshes the toolkit modal. */
+async function syncAllSubmodules() {
+    const git = createGitCommand();
+    git.syncAllSubmodules();
+    await openSubmodulesModal();
+}
+/** Registers the Git submodule toolkit menu and action handlers. */
+export function registerSubmoduleToolkit() {
+    const repoMenu = getOrCreateMenu('repository', 'Repository');
+    repoMenu?.addItem({ label: 'Submodules', action: 'repo-submodules' });
+    registerAction('repo-submodules', async () => {
+        console.log('Git submodules: repo-submodules action invoked');
+        return openSubmodulesModal();
+    });
+    registerAction('submodules-add', async (payload) => {
+        return addSubmodule(asPayload(payload));
+    });
+    registerAction('submodules-update-all', async () => {
+        return updateAllSubmodules();
+    });
+    registerAction('submodules-sync-all', async () => {
+        return syncAllSubmodules();
+    });
+    registerAction('submodules-update', async (payload) => {
+        return updateSubmodule(asPayload(payload));
+    });
+    registerAction('submodules-sync', async (payload) => {
+        return syncSubmodule(asPayload(payload));
+    });
+    registerAction('submodules-remove-request', async (payload) => {
+        const data = asPayload(payload);
+        return openRemoveConfirmationModal(payloadString(data, 'path'), payloadString(data, 'name'));
+    });
+    registerAction('submodules-remove-confirm', async (payload) => {
+        return removeSubmodule(asPayload(payload));
+    });
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@openvcs/git-plugin",
+  "version": "0.1.0",
+  "description": "OpenVCS Git plugin - Node.js runtime",
+  "license": "GPL-3.0-or-later",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "openvcs": {
+    "id": "openvcs.git",
+    "name": "Git",
+    "version": "0.1.0",
+    "author": "OpenVCS Contributors",
+    "description": "Git VCS backend plugin for OpenVCS",
+    "default_enabled": true,
+    "module": {
+      "exec": "openvcs-git-plugin.js",
+      "vcs_backends": [
+        "git"
+      ]
+    }
+  },
+  "scripts": {
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx --test test/*.test.ts",
+    "prepack": "npm run build",
+    "build:plugin": "tsc -p tsconfig.json",
+    "build": "node ./node_modules/@openvcs/sdk/bin/openvcs.js build"
+  },
+  "dependencies": {
+    "@openvcs/sdk": "^0.2.16"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsx": "^4.20.6",
+    "typescript": "^6.0.2"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "tsconfig.json",
+    "README.md",
+    "ARCHITECTURE.md",
+    "icon.png",
+    "LICENSE"
+  ]
+}