git-personas 1.0.0

package/dist/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import App from './index.js';
+render(React.createElement(App));

package/dist/components/BackButton.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export default function BackButton({ label = '← Back (Esc)' }) {
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: label }) }));
+}

package/dist/components/DeleteScreen.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { deletePersona, saveStore } from '../store.js';
+import BackButton from './BackButton.js';
+export default function DeleteScreen({ store, onScreenChange }) {
+    const items = store.personas.map((p) => ({
+        label: `🗑️  ${p.name} — ${p.user} <${p.email}>`,
+        value: p.name,
+    }));
+    const onSelect = (item) => {
+        const updated = deletePersona(item.value, store);
+        saveStore(updated);
+        onScreenChange({ type: 'success', message: `Deleted persona "${item.value}"` });
+    };
+    useInput((_input, key) => {
+        if (key.escape)
+            onScreenChange({ type: 'main' });
+    });
+    if (store.personas.length === 0) {
+        useInput((_input, key) => {
+            if (key.return || key.escape)
+                onScreenChange({ type: 'main' });
+        });
+        return (_jsxs(Box, { padding: 1, children: [_jsx(Text, { children: "No personas to delete." }), _jsx(Text, { dimColor: true, children: "Press Enter or Esc to go back" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "\uD83D\uDDD1\uFE0F Select persona to delete" }), _jsx(Box, { marginTop: 1 }), _jsx(SelectInput, { items: items, onSelect: onSelect }), _jsx(BackButton, {})] }));
+}

package/dist/components/EditSelectScreen.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import BackButton from './BackButton.js';
+export default function EditSelectScreen({ store, onScreenChange }) {
+    const items = store.personas.map((p) => ({
+        label: `${p.name} — ${p.user} <${p.email}>`,
+        value: p.name,
+    }));
+    const onSelect = (item) => {
+        onScreenChange({ type: 'edit', name: item.value });
+    };
+    useInput((_input, key) => {
+        if (key.escape)
+            onScreenChange({ type: 'main' });
+    });
+    if (store.personas.length === 0) {
+        useInput((_input, key) => {
+            if (key.return || key.escape)
+                onScreenChange({ type: 'main' });
+        });
+        return (_jsxs(Box, { padding: 1, children: [_jsx(Text, { children: "No personas to edit. Create one first." }), _jsx(Text, { dimColor: true, children: "Press Enter or Esc to go back" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "\u270F\uFE0F Select persona to edit" }), _jsx(Box, { marginTop: 1 }), _jsx(SelectInput, { items: items, onSelect: onSelect }), _jsx(BackButton, {})] }));
+}

package/dist/components/MainScreen.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { getPersona } from '../store.js';
+export default function MainScreen({ store, onScreenChange, onQuit }) {
+    const activePersona = store.active ? getPersona(store.active, store) : null;
+    const menuItems = [
+        { label: '➕ Create Persona', value: 'create' },
+        { label: '✏️  Edit Persona', value: 'edit' },
+        { label: '🗑️  Delete Persona', value: 'delete' },
+        { label: '🔄 Switch Persona', value: 'switch' },
+        { label: '🚪 Quit', value: 'quit' },
+    ];
+    const onSelect = (item) => {
+        switch (item.value) {
+            case 'create':
+                onScreenChange({ type: 'create' });
+                break;
+            case 'edit':
+                onScreenChange({ type: 'edit', name: '' });
+                break;
+            case 'delete':
+                onScreenChange({ type: 'delete' });
+                break;
+            case 'switch':
+                onScreenChange({ type: 'switch' });
+                break;
+            case 'quit':
+                onQuit();
+                break;
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "\uD83E\uDDD1\u200D\uD83D\uDCBC Git Personas" }), _jsx(Box, { marginTop: 1 }), activePersona ? (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "\u25CF Active: " }), _jsx(Text, { bold: true, children: activePersona.name }), _jsxs(Text, { children: [" (", activePersona.user, " <", activePersona.email, ">)"] })] })) : (_jsx(Text, { color: "yellow", children: "\u25CF No active persona" })), _jsx(Box, { marginTop: 1 }), store.personas.length > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Your personas:" }), store.personas.map((p) => (_jsx(Box, { children: _jsxs(Text, { children: ['  ', p.name === store.active ? '🟢' : '⚪', " ", p.name, _jsxs(Text, { dimColor: true, children: [" \u2014 ", p.user, " <", p.email, ">"] })] }) }, p.name))), _jsx(Box, { marginTop: 1 })] })) : (_jsx(Text, { dimColor: true, children: "No personas yet. Create one to get started." })), _jsx(Box, { marginTop: 1 }), _jsx(SelectInput, { items: menuItems, onSelect: onSelect })] }));
+}

package/dist/components/PersonaForm.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import TextInput from 'ink-text-input';
+import { detectGpgKeys, detectSshKeys } from '../store.js';
+import BackButton from './BackButton.js';
+export default function PersonaForm({ initial, onSubmit, onCancel, title }) {
+    const gpgKeys = detectGpgKeys();
+    const sshKeys = detectSshKeys();
+    const [name, setName] = useState(initial?.name || '');
+    const [user, setUser] = useState(initial?.user || '');
+    const [email, setEmail] = useState(initial?.email || '');
+    const [gpgKey, setGpgKey] = useState(initial?.gpgKey || '');
+    const [sshKey, setSshKey] = useState(initial?.sshKey || '');
+    const [defaultBranch, setDefaultBranch] = useState(initial?.defaultBranch || '');
+    const [step, setStep] = useState(0);
+    const isEdit = !!initial?.name;
+    const steps = isEdit
+        ? ['user', 'email', 'gpg', 'ssh', 'branch', 'confirm']
+        : ['name', 'user', 'email', 'gpg', 'ssh', 'branch', 'confirm'];
+    const currentStep = steps[step];
+    // Global Escape handler: go back a step or cancel
+    useInput((_input, key) => {
+        if (key.escape && !['gpg', 'ssh'].includes(currentStep)) {
+            if (step > 0) {
+                setStep(step - 1);
+            }
+            else {
+                onCancel();
+            }
+        }
+    });
+    const handleGpgSelect = (item) => {
+        setGpgKey(item.value);
+        setStep(step + 1);
+    };
+    const handleSshSelect = (item) => {
+        setSshKey(item.value);
+        setStep(step + 1);
+    };
+    const handleSubmit = () => {
+        if (!name.trim() || !user.trim() || !email.trim())
+            return;
+        onSubmit({
+            name: name.trim(),
+            user: user.trim(),
+            email: email.trim(),
+            gpgKey: gpgKey || undefined,
+            sshKey: sshKey || undefined,
+            defaultBranch: defaultBranch.trim() || undefined,
+        });
+    };
+    // Confirm step: Enter submits, Escape goes back
+    useInput((_input, key) => {
+        if (currentStep === 'confirm') {
+            if (key.return)
+                handleSubmit();
+            if (key.escape)
+                setStep(step - 1);
+        }
+    });
+    // Escape handler for GPG/SSH select screens
+    useInput((_input, key) => {
+        if (key.escape && ['gpg', 'ssh'].includes(currentStep)) {
+            setStep(step - 1);
+        }
+    });
+    if (currentStep === 'gpg') {
+        const items = [
+            { label: '(none — skip GPG signing)', value: '' },
+            ...gpgKeys.map((k) => ({
+                label: `${k.uid} [${k.id}]`,
+                value: k.id,
+            })),
+        ];
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "\uD83D\uDD11 Select GPG Signing Key" }), _jsxs(Text, { dimColor: true, children: ["Current: ", gpgKey || '(none)'] }), _jsx(Box, { marginTop: 1 }), _jsx(SelectInput, { items: items, onSelect: handleGpgSelect }), _jsx(BackButton, {})] }));
+    }
+    if (currentStep === 'ssh') {
+        const items = [
+            { label: '(none — use default SSH)', value: '' },
+            ...sshKeys.map((k) => ({
+                label: `${k.comment} (${k.path})`,
+                value: k.path,
+            })),
+        ];
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "\uD83D\uDD11 Select SSH Key" }), _jsxs(Text, { dimColor: true, children: ["Current: ", sshKey || '(none)'] }), _jsx(Box, { marginTop: 1 }), _jsx(SelectInput, { items: items, onSelect: handleSshSelect }), _jsx(BackButton, {})] }));
+    }
+    if (currentStep === 'confirm') {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: title }), _jsx(Box, { marginTop: 1 }), _jsxs(Text, { children: ["  Name: ", _jsx(Text, { bold: true, children: name })] }), _jsxs(Text, { children: ["  User: ", user] }), _jsxs(Text, { children: ["  Email: ", email] }), _jsxs(Text, { children: ["  GPG Key: ", gpgKey || '(none)'] }), _jsxs(Text, { children: ["  SSH Key: ", sshKey || '(none)'] }), _jsxs(Text, { children: ["  Default Branch: ", defaultBranch || '(system default)'] }), _jsx(Box, { marginTop: 1 }), _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Esc to go back" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: title }), _jsxs(Text, { dimColor: true, children: ["Step ", step + 1, " of ", steps.length] }), _jsx(Box, { marginTop: 1 }), currentStep === 'name' && (_jsxs(Box, { children: [_jsx(Text, { children: "Name: " }), _jsx(TextInput, { value: name, onChange: setName, onSubmit: () => setStep(1), placeholder: "e.g. work, personal" }), _jsx(Text, { dimColor: true, children: "Press Enter to continue" })] })), currentStep === 'user' && (_jsxs(Box, { children: [_jsx(Text, { children: "Git User Name: " }), _jsx(TextInput, { value: user, onChange: setUser, onSubmit: () => setStep(step + 1), placeholder: "e.g. Phil" }), _jsx(Text, { dimColor: true, children: "Press Enter to continue" })] })), currentStep === 'email' && (_jsxs(Box, { children: [_jsx(Text, { children: "Git Email: " }), _jsx(TextInput, { value: email, onChange: setEmail, onSubmit: () => setStep(step + 1), placeholder: "e.g. phil@example.com" }), _jsx(Text, { dimColor: true, children: "Press Enter to continue" })] })), currentStep === 'branch' && (_jsxs(Box, { children: [_jsx(Text, { children: "Default Branch: " }), _jsx(TextInput, { value: defaultBranch, onChange: setDefaultBranch, onSubmit: () => setStep(step + 1), placeholder: "e.g. main (leave empty for default)" }), _jsx(Text, { dimColor: true, children: "Press Enter to continue (leave blank to skip)" })] })), _jsx(BackButton, {})] }));
+}

package/dist/components/SuccessScreen.js

@@ -0,0 +1,21 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+export default function SuccessScreen({ message, onContinue, onQuit }) {
+    useInput((_input, key) => {
+        if (key.return)
+            onContinue();
+        if (key.escape)
+            onQuit();
+    });
+    const items = [
+        { label: 'Continue', value: 'continue' },
+        { label: '🚪 Quit', value: 'quit' },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "green", children: ["\u2713 ", message] }), _jsx(Box, { marginTop: 1 }), _jsx(SelectInput, { items: items, onSelect: (item) => {
+                    if (item.value === 'continue')
+                        onContinue();
+                    if (item.value === 'quit')
+                        onQuit();
+                } })] }));
+}

package/dist/components/SwitchScreen.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { getPersona, applyPersona, clearActivePersona, setActive, saveStore } from '../store.js';
+import BackButton from './BackButton.js';
+export default function SwitchScreen({ store, onScreenChange }) {
+    const items = [
+        { label: '⚪  (none — clear active persona)', value: '__none__' },
+        ...store.personas.map((p) => ({
+            label: `${p.name === store.active ? '🟢' : '⚪'} ${p.name} — ${p.user} <${p.email}>`,
+            value: p.name,
+        })),
+    ];
+    const onSelect = (item) => {
+        if (item.value === '__none__') {
+            clearActivePersona();
+            const updated = setActive(null, store);
+            saveStore(updated);
+            onScreenChange({ type: 'success', message: 'Cleared active persona' });
+        }
+        else {
+            const persona = getPersona(item.value, store);
+            if (persona) {
+                applyPersona(persona);
+                const updated = setActive(item.value, store);
+                saveStore(updated);
+                onScreenChange({ type: 'success', message: `Switched to "${item.value}"` });
+            }
+        }
+    };
+    useInput((_input, key) => {
+        if (key.escape)
+            onScreenChange({ type: 'main' });
+    });
+    if (store.personas.length === 0) {
+        useInput((_input, key) => {
+            if (key.return || key.escape)
+                onScreenChange({ type: 'main' });
+        });
+        return (_jsxs(Box, { padding: 1, children: [_jsx(Text, { children: "No personas to switch to." }), _jsx(Text, { dimColor: true, children: "Press Enter or Esc to go back" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "\uD83D\uDD04 Switch Active Persona" }), _jsx(Box, { marginTop: 1 }), _jsx(SelectInput, { items: items, onSelect: onSelect }), _jsx(BackButton, {})] }));
+}

package/dist/index.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { useInput, useApp } from 'ink';
+import { loadStore, saveStore, ensureConfigDir, addPersona, updatePersona, getPersona, applyPersona } from './store.js';
+import MainScreen from './components/MainScreen.js';
+import PersonaForm from './components/PersonaForm.js';
+import EditSelectScreen from './components/EditSelectScreen.js';
+import DeleteScreen from './components/DeleteScreen.js';
+import SwitchScreen from './components/SwitchScreen.js';
+import SuccessScreen from './components/SuccessScreen.js';
+export default function App() {
+    const { exit } = useApp();
+    const [screen, setScreen] = useState({ type: 'main' });
+    // Global: Escape on main screen quits the app
+    useInput((_input, key) => {
+        if (key.escape && screen.type === 'main') {
+            exit();
+        }
+    });
+    const store = loadStore();
+    switch (screen.type) {
+        case 'main':
+            return (_jsx(MainScreen, { store: store, onScreenChange: setScreen, onQuit: exit }));
+        case 'create': {
+            return (_jsx(PersonaForm, { title: "\u2795 Create Persona", onSubmit: (persona) => {
+                    try {
+                        ensureConfigDir();
+                        const updated = addPersona(persona, store);
+                        saveStore(updated);
+                        setScreen({ type: 'success', message: `Created persona "${persona.name}"` });
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        setScreen({ type: 'success', message: `Error: ${msg}` });
+                    }
+                }, onCancel: () => setScreen({ type: 'main' }) }));
+        }
+        case 'edit': {
+            if (!screen.name) {
+                return (_jsx(EditSelectScreen, { store: store, onScreenChange: setScreen }));
+            }
+            const persona = getPersona(screen.name, store);
+            if (!persona) {
+                return (_jsx(SuccessScreen, { message: "Persona not found.", onContinue: () => setScreen({ type: 'main' }), onQuit: exit }));
+            }
+            return (_jsx(PersonaForm, { title: `✏️ Edit "${persona.name}"`, initial: persona, onSubmit: (updated) => {
+                    const newStore = updatePersona(screen.name, updated, store);
+                    saveStore(newStore);
+                    if (store.active === screen.name) {
+                        applyPersona(updated);
+                    }
+                    setScreen({ type: 'success', message: `Updated persona "${persona.name}"` });
+                }, onCancel: () => setScreen({ type: 'main' }) }));
+        }
+        case 'delete':
+            return _jsx(DeleteScreen, { store: store, onScreenChange: setScreen });
+        case 'switch':
+            return _jsx(SwitchScreen, { store: store, onScreenChange: setScreen });
+        case 'success':
+            return (_jsx(SuccessScreen, { message: screen.message, onContinue: () => setScreen({ type: 'main' }), onQuit: exit }));
+    }
+}

package/dist/store.js

@@ -0,0 +1,136 @@
+import { execSync } from 'child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+const CONFIG_DIR = `${os.homedir()}/.config/git-personas`;
+const CONFIG_FILE = `${CONFIG_DIR}/personas.json`;
+export function ensureConfigDir() {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+export function loadStore() {
+    try {
+        const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return { personas: [], active: null };
+    }
+}
+export function saveStore(store) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(store, null, 2));
+}
+export function getPersona(name, store) {
+    return store.personas.find((p) => p.name === name);
+}
+export function addPersona(persona, store) {
+    if (store.personas.find((p) => p.name === persona.name)) {
+        throw new Error(`Persona "${persona.name}" already exists`);
+    }
+    return { ...store, personas: [...store.personas, persona] };
+}
+export function updatePersona(name, updates, store) {
+    return {
+        ...store,
+        personas: store.personas.map((p) => p.name === name ? { ...p, ...updates } : p),
+    };
+}
+export function deletePersona(name, store) {
+    return {
+        ...store,
+        personas: store.personas.filter((p) => p.name !== name),
+        active: store.active === name ? null : store.active,
+    };
+}
+export function setActive(name, store) {
+    return { ...store, active: name };
+}
+export function detectGpgKeys() {
+    try {
+        const output = execSync('gpg --list-keys --with-colons 2>/dev/null', {
+            encoding: 'utf-8',
+        });
+        const keys = [];
+        const lines = output.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('pub:')) {
+                const parts = line.split(':');
+                const keyId = parts[4];
+                const uid = parts[9] || '';
+                if (keyId && uid) {
+                    keys.push({
+                        id: keyId,
+                        uid: uid.substring(0, 60),
+                    });
+                }
+            }
+        }
+        return keys;
+    }
+    catch {
+        return [];
+    }
+}
+export function detectSshKeys() {
+    try {
+        const sshDir = `${os.homedir()}/.ssh`;
+        const keys = [];
+        const files = fs.readdirSync(sshDir);
+        for (const file of files) {
+            if (file.startsWith('id_') && !file.endsWith('.pub') && !file.endsWith('.pem')) {
+                const pubFile = `${sshDir}/${file}.pub`;
+                try {
+                    const comment = fs.readFileSync(pubFile, 'utf-8').trim().split(' ').slice(2).join(' ');
+                    keys.push({ path: `${sshDir}/${file}`, comment: comment || file });
+                }
+                catch {
+                    keys.push({ path: `${sshDir}/${file}`, comment: file });
+                }
+            }
+        }
+        return keys;
+    }
+    catch {
+        return [];
+    }
+}
+export function applyPersona(persona) {
+    const commands = [
+        `git config --global user.name "${persona.user}"`,
+        `git config --global user.email "${persona.email}"`,
+    ];
+    if (persona.gpgKey) {
+        commands.push(`git config --global user.signingkey ${persona.gpgKey}`, `git config --global commit.gpgsign true`);
+    }
+    else {
+        commands.push(`git config --global --unset commit.gpgsign || true`);
+        commands.push(`git config --global --unset user.signingkey || true`);
+    }
+    if (persona.sshKey) {
+        commands.push(`git config --global core.sshCommand "ssh -i ${persona.sshKey} -o IdentitiesOnly=yes"`);
+    }
+    else {
+        commands.push(`git config --global --unset core.sshCommand || true`);
+    }
+    if (persona.defaultBranch) {
+        commands.push(`git config --global init.defaultBranch ${persona.defaultBranch}`);
+    }
+    else {
+        commands.push(`git config --global --unset init.defaultBranch || true`);
+    }
+    for (const cmd of commands) {
+        execSync(cmd, { stdio: 'pipe' });
+    }
+}
+export function clearActivePersona() {
+    const commands = [
+        `git config --global --unset user.name || true`,
+        `git config --global --unset user.email || true`,
+        `git config --global --unset user.signingkey || true`,
+        `git config --global --unset commit.gpgsign || true`,
+        `git config --global --unset core.sshCommand || true`,
+        `git config --global --unset init.defaultBranch || true`,
+    ];
+    for (const cmd of commands) {
+        execSync(cmd, { stdio: 'pipe' });
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "git-personas",
+  "version": "1.0.0",
+  "description": "Terminal UI for managing git personas — switch between git identities with ease",
+  "main": "dist/cli.js",
+  "bin": {
+    "git-personas": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.tsx",
+    "build": "tsc",
+    "start": "node dist/cli.js",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "typecheck": "tsc --noEmit",
+    "check": "npm run typecheck && npm run lint",
+    "prepublishOnly": "npm run check && npm run build",
+    "prepare": "simple-git-hooks"
+  },
+  "keywords": [
+    "git",
+    "persona",
+    "identity",
+    "config",
+    "cli",
+    "terminal",
+    "tui",
+    "ink",
+    "switch",
+    "profile"
+  ],
+  "author": "Phil Oliver",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "dependencies": {
+    "ink": "^5.2.0",
+    "ink-select-input": "^6.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^22.15.21",
+    "@types/react": "^18.3.30",
+    "@typescript-eslint/parser": "^8.60.1",
+    "eslint": "^10.0.1",
+    "react-dom": "^18.3.1",
+    "simple-git-hooks": "^2.13.1",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.60.1"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "npm run check"
+  }
+}