johankit 0.1.5 → 1.0.0

package/dist/src/cli/commands/sync.js

@@ -0,0 +1,166 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sync = sync;
+// src/cli/commands/sync.ts
+const scan_1 = require("../../core/scan");
+const schema_1 = require("../../core/schema");
+const diff_1 = require("../../core/diff");
+const child_process_1 = require("child_process");
+const cleanCodeBlock_1 = __importDefault(require("../../utils/cleanCodeBlock"));
+const readline_1 = __importDefault(require("readline"));
+const clipboard_1 = require("../../core/clipboard");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const diff = __importStar(require("diff"));
+require("colors");
+const INTERNAL_MARKER = "__JOHANKIT_INTERNAL__";
+async function confirm(msg) {
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(`${msg} (y/N): `, ans => {
+            rl.close();
+            resolve(ans.toLowerCase() === 'y');
+        });
+    });
+}
+function showDiff(filename, oldContent, newContent) {
+    console.log(`\n--- DIFF FOR: ${filename.bold} ---`);
+    const patches = diff.diffLines(oldContent, newContent);
+    patches.forEach((part) => {
+        const color = part.added ? 'green' : part.removed ? 'red' : 'gray';
+        const prefix = part.added ? '+' : part.removed ? '-' : ' ';
+        const value = part.value.endsWith('\n') ? part.value : part.value + '\n';
+        process.stdout.write((value.split('\n').map(line => line ? `${prefix}${line}` : '').join('\n'))[color]);
+    });
+    console.log('\n-----------------------');
+}
+async function processInput(input, dir, runAll, dryRun, interactiveDiff) {
+    const autoAccept = process.argv.includes('-y');
+    const { cleaned } = (0, cleanCodeBlock_1.default)(input);
+    let patchesData;
+    try {
+        patchesData = JSON.parse(cleaned);
+    }
+    catch {
+        return false;
+    }
+    const patches = (0, schema_1.validatePatches)(patchesData);
+    if (patches.length === 0)
+        return false;
+    for (const patch of patches) {
+        if (patch.type === 'console' && patch.command) {
+            if (dryRun) {
+                process.stdout.write(`[DRY-RUN] Would execute: ${patch.command}\n`);
+            }
+            else if (runAll) {
+                const ok = autoAccept || await confirm(`> Execute: ${patch.command}`);
+                if (ok)
+                    (0, child_process_1.execSync)(patch.command, { stdio: 'inherit', cwd: dir });
+            }
+        }
+        else if (patch.path) {
+            const fullPath = path_1.default.join(dir, patch.path);
+            const exists = fs_1.default.existsSync(fullPath);
+            const oldContent = exists ? fs_1.default.readFileSync(fullPath, 'utf8') : "";
+            const newContent = patch.content || "";
+            if (interactiveDiff && patch.content !== null) {
+                showDiff(patch.path, oldContent, newContent);
+                if (await confirm(`Apply changes to ${patch.path}?`)) {
+                    (0, diff_1.applyDiff)(dir, [patch]);
+                }
+                else {
+                    console.log(`Skipped: ${patch.path}`);
+                }
+            }
+            else if (dryRun) {
+                const action = patch.content === null ? "Delete" : "Write";
+                process.stdout.write(`[DRY-RUN] Would ${action}: ${patch.path}\n`);
+            }
+            else {
+                (0, diff_1.applyDiff)(dir, [patch]);
+            }
+        }
+    }
+    return true;
+}
+async function sync(dir, runAll = false, dryRun = false, interactiveDiff = false, watch = false) {
+    try {
+        const snapshotBefore = (0, scan_1.scanDir)(dir);
+        const systemPrompt = `YOU ARE AN AI SOFTWARE ENGINEER.\nALWAYS RESPOND USING ONLY A JSON PATCH ARRAY.\n\nSNAPSHOT:\n${JSON.stringify(snapshotBefore, null, 2)}`;
+        await (0, clipboard_1.copyToClipboard)(INTERNAL_MARKER + systemPrompt);
+        process.stdout.write("[johankit] System Prompt + Snapshot copied to clipboard\n");
+        if (watch) {
+            process.stdout.write("[johankit] Watching clipboard for AI response (Ctrl+C to stop)\n");
+            let lastClipboard = await (0, clipboard_1.readClipboard)();
+            while (true) {
+                await new Promise(r => setTimeout(r, 1000));
+                const currentClipboard = await (0, clipboard_1.readClipboard)();
+                if (!currentClipboard || currentClipboard === lastClipboard)
+                    continue;
+                lastClipboard = currentClipboard;
+                if (currentClipboard.startsWith(INTERNAL_MARKER))
+                    continue;
+                const success = await processInput(currentClipboard, dir, runAll, dryRun, interactiveDiff);
+                if (success) {
+                    process.stdout.write("[johankit] Patch applied from clipboard\n");
+                    const snapshotAfter = (0, scan_1.scanDir)(dir);
+                    await (0, clipboard_1.copyToClipboard)(INTERNAL_MARKER + JSON.stringify(snapshotAfter, null, 2));
+                    process.stdout.write("[johankit] Updated snapshot copied to clipboard\n");
+                }
+            }
+        }
+        else {
+            process.stdout.write("[johankit] Paste AI response into clipboard and press Enter\n");
+            await confirm('');
+            const input = await (0, clipboard_1.readClipboard)();
+            if (!input)
+                throw new Error("Clipboard is empty");
+            const success = await processInput(input, dir, runAll, dryRun, interactiveDiff);
+            if (success && !dryRun) {
+                const snapshotAfter = (0, scan_1.scanDir)(dir);
+                await (0, clipboard_1.copyToClipboard)(INTERNAL_MARKER + JSON.stringify(snapshotAfter, null, 2));
+                process.stdout.write("[johankit] Sync applied and snapshot copied to clipboard\n");
+            }
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[johankit] Sync failed: ${e.message}\n`);
+        process.exit(1);
+    }
+}

package/dist/src/core/clipboard.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyToClipboard = copyToClipboard;
+exports.readClipboard = readClipboard;
+// src/core/clipboard.ts
+const child_process_1 = require("child_process");
+const clipboardy_1 = __importDefault(require("clipboardy"));
+async function copyToClipboard(text) {
+    const platform = process.platform;
+    const isWSL = process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP;
+    return new Promise((resolve, reject) => {
+        let command = "";
+        let args = [];
+        if (isWSL) {
+            command = "clip.exe";
+        }
+        else if (platform === "darwin") {
+            command = "pbcopy";
+        }
+        else if (platform === "win32") {
+            command = "clip";
+        }
+        else {
+            command = "xclip";
+            args = ["-selection", "clipboard"];
+        }
+        try {
+            const child = (0, child_process_1.spawn)(command, args);
+            child.on("error", (err) => reject(err));
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Clipboard error: ${code}`));
+            });
+            child.stdin.write(text);
+            child.stdin.end();
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+async function readClipboard() {
+    try {
+        return await clipboardy_1.default.read();
+    }
+    catch (err) {
+        return new Promise((resolve) => {
+            const platform = process.platform;
+            let command = platform === "darwin" ? "pbpaste" : platform === "win32" ? "powershell" : "xclip";
+            let args = platform === "win32" ? ["-NoProfile", "-Command", "Get-Clipboard"] :
+                platform === "linux" ? ["-selection", "clipboard", "-o"] : [];
+            const child = (0, child_process_1.spawn)(command, args);
+            let output = "";
+            child.stdout.on("data", (d) => (output += d.toString()));
+            child.on("close", () => resolve(output.trim()));
+            child.on("error", () => resolve(""));
+        });
+    }
+}

package/dist/src/core/config.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const js_yaml_1 = require("js-yaml");
+const DEFAULT_IGNORE = [
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "tmp",
+    "temp",
+];
+function loadConfig(basePath) {
+    // Lista de possíveis nomes para o arquivo de configuração
+    const configFilenames = ["johankit.yaml", "johankit.yml"];
+    let loadedConfig = {};
+    for (const filename of configFilenames) {
+        const configPath = path_1.default.join(basePath, filename);
+        if ((0, fs_1.existsSync)(configPath)) {
+            try {
+                const content = (0, fs_1.readFileSync)(configPath, "utf8");
+                loadedConfig = (0, js_yaml_1.load)(content) || {};
+                break; // Para no primeiro que encontrar
+            }
+            catch (error) {
+                console.warn(`[johankit] Erro ao ler ${filename}, tentando próximo...`);
+            }
+        }
+    }
+    // Set para garantir que não existam duplicatas nos padrões de ignore
+    const ignoreSet = new Set([...DEFAULT_IGNORE, ...(loadedConfig.ignore || [])]);
+    return {
+        ignore: Array.from(ignoreSet),
+    };
+}

package/dist/{core → src/core}/diff.js

@@ -9,20 +9,17 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 function applyDiff(basePath, patches) {
     for (const patch of patches) {
+        if (!patch.path)
+            continue;
         const fullPath = path_1.default.join(basePath, patch.path);
-        switch (patch.type) {
-            case "delete": {
-                if (fs_1.default.existsSync(fullPath)) {
-                    fs_1.default.unlinkSync(fullPath);
-                }
-                break;
-            }
-            case "create":
-            case "modify": {
-                fs_1.default.mkdirSync(path_1.default.dirname(fullPath), { recursive: true });
-                fs_1.default.writeFileSync(fullPath, patch.content ?? "", "utf8");
-                break;
+        if (patch.content === null || patch.content === undefined) {
+            if (fs_1.default.existsSync(fullPath)) {
+                fs_1.default.unlinkSync(fullPath);
             }
         }
+        else {
+            fs_1.default.mkdirSync(path_1.default.dirname(fullPath), { recursive: true });
+            fs_1.default.writeFileSync(fullPath, patch.content, "utf8");
+        }
     }
 }

package/dist/src/core/scan.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanDir = scanDir;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+// Cache para evitar re-leitura de configurações durante o mesmo processo
+let cachedConfig = null;
+let cachedIgnoreList = null;
+function scanDir(basePath, options = {}) {
+    const result = [];
+    const base = path_1.default.resolve(basePath);
+    const exts = options.extensions?.map(e => e.startsWith('.') ? e : `.${e}`);
+    if (!cachedConfig) {
+        cachedConfig = (0, config_1.loadConfig)(base);
+        const ignorePatterns = new Set(cachedConfig.ignore);
+        const gitignorePath = path_1.default.join(base, '.gitignore');
+        if (fs_1.default.existsSync(gitignorePath)) {
+            try {
+                fs_1.default.readFileSync(gitignorePath, 'utf8')
+                    .split('\n')
+                    .forEach(line => {
+                    const trimmed = line.trim();
+                    if (trimmed && !trimmed.startsWith('#')) {
+                        ignorePatterns.add(trimmed.replace(/^\//, '').replace(/\/$/, ''));
+                    }
+                });
+            }
+            catch { }
+        }
+        cachedIgnoreList = Array.from(ignorePatterns);
+    }
+    const finalIgnoreList = cachedIgnoreList;
+    function loop(currentPath) {
+        const entries = fs_1.default.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const name = entry.name;
+            // Otimização: Verificação rápida de binários e pastas ocultas comuns
+            if (name.startsWith('.') && name !== '.gitignore')
+                continue;
+            if (name.match(/\.(png|jpg|jpeg|gif|pdf|zip|exe|dll|so|db|map|lock)$/i))
+                continue;
+            const fullPath = path_1.default.join(currentPath, name);
+            const relPath = path_1.default.relative(base, fullPath).replace(/\\/g, '/');
+            const shouldIgnore = finalIgnoreList.some(p => relPath === p || relPath.startsWith(p + '/'));
+            if (shouldIgnore)
+                continue;
+            if (entry.isDirectory()) {
+                loop(fullPath);
+            }
+            else {
+                if (exts && !exts.includes(path_1.default.extname(name)))
+                    continue;
+                try {
+                    const stats = fs_1.default.statSync(fullPath);
+                    // Ignora arquivos maiores que 200KB para manter performance do clipboard
+                    if (stats.size > 200 * 1024)
+                        continue;
+                    result.push({
+                        path: relPath,
+                        content: fs_1.default.readFileSync(fullPath, 'utf8')
+                    });
+                }
+                catch (e) {
+                    continue;
+                }
+            }
+        }
+    }
+    loop(base);
+    return result;
+}

package/dist/src/core/schema.js

@@ -0,0 +1,18 @@
+"use strict";
+// src/core/schema.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePatches = validatePatches;
+function validatePatches(json) {
+    if (!Array.isArray(json)) {
+        throw new Error("Input must be a valid JSON array");
+    }
+    // Validação permissiva: ou tem path (arquivo) ou tem type console + command
+    return json.map((item, index) => {
+        const isFile = typeof item.path === 'string';
+        const isCommand = item.type === 'console' && typeof item.command === 'string';
+        if (!isFile && !isCommand) {
+            throw new Error(`Item at index ${index} is invalid. Must have 'path' or 'type: console'`);
+        }
+        return item;
+    });
+}

package/dist/src/core/validation.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePatches = validatePatches;
+// src/core/validation.ts
+const schema_1 = require("./schema");
+/**
+ * @deprecated Use validatePatches from core/schema instead.
+ */
+function validatePatches(json) {
+    return (0, schema_1.validatePatches)(json);
+}

package/dist/src/core/write.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFiles = writeFiles;
+// src/core/write.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * @deprecated Use applyDiff from core/diff for more flexibility (supports deletes and console commands).
+ */
+function writeFiles(basePath, files, commit = true) {
+    // if (commit && files.length > 0) {
+    //   ensureGitCommit("johankit: before write");
+    // }
+    for (const file of files) {
+        if (!file.path)
+            continue;
+        const fullPath = path_1.default.join(basePath, file.path);
+        fs_1.default.mkdirSync(path_1.default.dirname(fullPath), { recursive: true });
+        fs_1.default.writeFileSync(fullPath, file.content || "", "utf8");
+    }
+}

package/dist/src/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const copy_1 = require("./cli/commands/copy");
+const paste_1 = require("./cli/commands/paste");
+const prompt_1 = require("./cli/commands/prompt");
+const sync_1 = require("./cli/commands/sync");
+const program = new commander_1.Command();
+program
+    .name('johankit')
+    .description('Developer-friendly CLI for codebase snapshots and AI vibe-coding')
+    .version('0.0.3');
+program
+    .command('copy [dir] [exts]')
+    .action((dir = '.', exts) => (0, copy_1.copy)(dir, exts?.split(',')));
+program
+    .command('paste [dir]')
+    .option('--run', 'execute console commands')
+    .option('-y', 'auto accept commands without confirmation')
+    .option('--dry-run', 'list changes without applying them')
+    .option('--diff', 'show diff and ask for confirmation for each file')
+    .action((dir = '.', opts) => (0, paste_1.paste)(dir, !!opts.run, !!opts.dryRun, !!opts.diff));
+program
+    .command('prompt [dir] <request...>')
+    .action((dir = '.', request) => (0, prompt_1.prompt)(dir, request.join(' ')));
+program
+    .command('sync [dir]')
+    .option('--run', 'execute console commands')
+    .option('-y', 'auto accept commands without confirmation')
+    .option('--dry-run', 'list changes without applying them')
+    .option('--diff', 'show diff and ask for confirmation for each file')
+    .option('--watch', 'continuously watch clipboard for new patches')
+    .option('--auto', 'alias for --watch with auto-accept')
+    .action((dir = '.', opts) => {
+    const isAuto = !!opts.auto;
+    (0, sync_1.sync)(dir, isAuto || !!opts.run, !!opts.dryRun, !!opts.diff, isAuto || !!opts.watch);
+});
+program.parse();

package/dist/src/tests/cleanCodeBlock.test.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cleanCodeBlock_1 = __importDefault(require("../utils/cleanCodeBlock"));
+describe('cleanCodeBlock', () => {
+    it('should extract JSON from markdown blocks', () => {
+        const input = 'Check this: ```json [{"path": "test"}] ``` and some text';
+        const { cleaned } = (0, cleanCodeBlock_1.default)(input);
+        expect(cleaned).toBe('[{"path": "test"}]');
+    });
+    it('should handle raw JSON arrays', () => {
+        const input = '[{"path": "test"}]';
+        const { cleaned } = (0, cleanCodeBlock_1.default)(input);
+        expect(cleaned).toBe('[{"path": "test"}]');
+    });
+    it('should remove invisible characters', () => {
+        const input = '\uFEFF[{"path": "test"}]';
+        const { cleaned } = (0, cleanCodeBlock_1.default)(input);
+        expect(cleaned).toBe('[{"path": "test"}]');
+    });
+});

package/dist/src/tests/scan.test.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const scan_1 = require("../core/scan");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+describe('scanDir', () => {
+    const testDir = path_1.default.join(__dirname, 'test-tmp');
+    beforeEach(() => {
+        if (fs_1.default.existsSync(testDir))
+            fs_1.default.rmSync(testDir, { recursive: true });
+        fs_1.default.mkdirSync(testDir);
+    });
+    afterEach(() => {
+        if (fs_1.default.existsSync(testDir))
+            fs_1.default.rmSync(testDir, { recursive: true });
+    });
+    it('should scan files in a directory', () => {
+        fs_1.default.writeFileSync(path_1.default.join(testDir, 'test.ts'), 'console.log("hello")');
+        const results = (0, scan_1.scanDir)(testDir);
+        expect(results.length).toBe(1);
+        expect(results[0].path).toBe('test.ts');
+        expect(results[0].content).toBe('console.log("hello")');
+    });
+    it('should respect ignore patterns from config', () => {
+        fs_1.default.mkdirSync(path_1.default.join(testDir, 'node_modules'));
+        fs_1.default.writeFileSync(path_1.default.join(testDir, 'node_modules/ignore.ts'), 'ignore');
+        fs_1.default.writeFileSync(path_1.default.join(testDir, 'keep.ts'), 'keep');
+        const results = (0, scan_1.scanDir)(testDir);
+        expect(results.find(r => r.path.includes('node_modules'))).toBeUndefined();
+        expect(results.find(r => r.path === 'keep.ts')).toBeDefined();
+    });
+});

package/dist/src/tests/schema.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("../core/schema");
+describe('validatePatches', () => {
+    it('should validate correct file patches', () => {
+        const input = [{ path: 'src/index.ts', content: 'test' }];
+        const output = (0, schema_1.validatePatches)(input);
+        expect(output).toEqual(input);
+    });
+    it('should validate correct console patches', () => {
+        const input = [{ type: 'console', command: 'npm install' }];
+        const output = (0, schema_1.validatePatches)(input);
+        expect(output).toEqual(input);
+    });
+    it('should throw error for invalid items', () => {
+        const input = [{ invalid: 'item' }];
+        expect(() => (0, schema_1.validatePatches)(input)).toThrow();
+    });
+    it('should throw error if input is not an array', () => {
+        expect(() => (0, schema_1.validatePatches)({})).toThrow();
+    });
+});

package/dist/src/utils/cleanCodeBlock.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = cleanCodeBlock;
+// src/utils/cleanCodeBlock.ts
+function cleanCodeBlock(content) {
+    // Regex robusta para capturar o primeiro array JSON ou bloco de código em string suja
+    const jsonRegex = /```json\s*([\s\S]*?)\s*```|(\[\s*{[\s\S]*}\s*\])/;
+    const match = content.match(jsonRegex);
+    let cleaned = match ? (match[1] || match[2]) : content;
+    cleaned = cleaned.replace(/^\uFEFF/, '');
+    cleaned = cleaned.replace(/[\u0000-\u0008\u000B-\u000C\u000E-\u001F\u007F-\u009F]/g, '');
+    return { cleaned: cleaned.trim() };
+}

package/dist/types.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// deleted as redundant to src/types.ts

package/johankit.yml

@@ -0,0 +1,6 @@
+ignore:
+  - node_modules
+  - .git
+  - dist
+  - yarn.lock
+  - package-lock.json

package/package.json

@@ -1,33 +1,43 @@
 {
   "name": "johankit",
-  "version": "0.1.5",
-  "description": "",
+  "version": "1.0.0",
+  "description": "Developer-friendly CLI for codebase snapshots and AI vibe-coding.",
   "main": "dist/index.js",
   "bin": {
-    "johankit": "./dist/index.js"
+    "johankit": "./dist/src/index.js"
   },
   "scripts": {
     "test": "jest",
     "build": "tsc",
-    "start": "ts-node src/index.ts"
+    "start": "ts-node src/index.ts",
+    "prepare": "npm run build"
   },
-  "keywords": [],
+  "keywords": [
+    "cli",
+    "ai",
+    "snapshot",
+    "vibe-coding",
+    "productivity"
+  ],
   "author": "",
   "license": "ISC",
+  "type": "commonjs",
   "devDependencies": {
     "@types/jest": "^29.5.3",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^25.0.1",
+    "@types/node": "^20.0.0",
     "jest": "^29.5.0",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
+    "typescript": "^5.0.0"
   },
   "dependencies": {
-    "clipboardy": "^5.0.2",
-    "commander": "^14.0.2",
+    "@types/diff": "^7.0.2",
+    "clipboardy": "^4.0.0",
+    "colors": "^1.4.0",
+    "commander": "^11.0.0",
+    "diff": "^8.0.2",
     "js-yaml": "^4.1.1",
-    "ts-morph": "^27.0.2",
     "vm2": "^3.10.0"
   }
 }