johankit 0.1.3 → 0.4.2

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

@@ -0,0 +1,173 @@
+"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");
+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 (e) {
+        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.
+ALWAYS RESPOND USING THE FOLLOWING JSON PATCH FORMAT ONLY.
+
+FORMAT:
+[{"path": "file.ts", "content": "full code"}, {"type": "console", "command": "npm install"}]
+
+SNAPSHOT:
+${JSON.stringify(snapshotBefore, null, 2)}
+
+PLEASE APPLY THE USER REQUESTS TO THIS SNAPSHOT AND RETURN ONLY THE JSON ARRAY.`;
+        await (0, clipboard_1.copyToClipboard)(systemPrompt);
+        process.stdout.write('√ System Prompt + Snapshot copied to clipboard.\n');
+        if (watch) {
+            process.stdout.write('√ Watching clipboard for AI response (Press 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 !== lastClipboard && currentClipboard.trim().length > 0) {
+                    lastClipboard = currentClipboard;
+                    const success = await processInput(currentClipboard, dir, runAll, dryRun, interactiveDiff);
+                    if (success) {
+                        process.stdout.write('√ Patch applied automatically from clipboard!\n');
+                        const snapshotAfter = (0, scan_1.scanDir)(dir);
+                        await (0, clipboard_1.copyToClipboard)(JSON.stringify(snapshotAfter, null, 2));
+                        process.stdout.write('√ Updated snapshot copied to clipboard. Ready for next turn.\n');
+                    }
+                }
+            }
+        }
+        else {
+            process.stdout.write('√ Go to your AI, paste it, copy the result, and come back here.\n');
+            await confirm('Press [Enter] when you have the AI response in your clipboard...');
+            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)(JSON.stringify(snapshotAfter, null, 2));
+                process.stdout.write('√ Sync applied! Updated snapshot is now in your clipboard.\n');
+            }
+        }
+    }
+    catch (e) {
+        process.stderr.write(`× 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,39 @@
+"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) {
+    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;
+            }
+            catch (error) {
+                console.warn(`[johankit] Erro ao ler ${filename}, tentando próximo...`);
+            }
+        }
+    }
+    const ignoreSet = new Set([...DEFAULT_IGNORE, ...(loadedConfig.ignore || [])]);
+    return {
+        ignore: Array.from(ignoreSet),
+    };
+}

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

@@ -3,27 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyDiff = void 0;
+exports.applyDiff = applyDiff;
 // src/core/diff.ts
 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");
+        }
     }
 }
-exports.applyDiff = applyDiff;

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureGitCommit = void 0;
+exports.ensureGitCommit = ensureGitCommit;
 // src/core/git.ts
 const child_process_1 = require("child_process");
 const crypto_1 = __importDefault(require("crypto"));
@@ -40,4 +40,3 @@ function ensureGitCommit(message) {
         // noop: no git or nothing to commit
     }
 }
-exports.ensureGitCommit = ensureGitCommit;

package/dist/src/core/scan.js

@@ -0,0 +1,70 @@
+"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");
+function scanDir(basePath, options = {}) {
+    const result = [];
+    const base = path_1.default.resolve(basePath);
+    const exts = options.extensions?.map(e => e.startsWith('.') ? e : `.${e}`);
+    const config = (0, config_1.loadConfig)(base);
+    const ignorePatterns = new Set(config.ignore);
+    // Lê .gitignore e adiciona ao Set
+    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('#')) {
+                    // Normaliza o caminho do gitignore para o padrão do scanner
+                    ignorePatterns.add(trimmed.replace(/^\//, '').replace(/\/$/, ''));
+                }
+            });
+        }
+        catch { }
+    }
+    // PERFORMANCE: Converte o Set em Array UMA VEZ antes de iniciar o loop
+    const finalIgnoreList = Array.from(ignorePatterns);
+    function loop(currentPath) {
+        const entries = fs_1.default.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const isBinary = entry.name.match(/\.(png|jpg|jpeg|gif|pdf|zip|exe|dll|so|db)$/i);
+            if (isBinary)
+                continue;
+            const fullPath = path_1.default.join(currentPath, entry.name);
+            const relPath = path_1.default.relative(base, fullPath).replace(/\\/g, '/');
+            // PERFORMANCE: O some() agora opera sobre um array fixo, sem Array.from() interno
+            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(entry.name)))
+                    continue;
+                try {
+                    // PERFORMANCE: Pular arquivos muito grandes evita travar o clipboard
+                    const stats = fs_1.default.statSync(fullPath);
+                    if (stats.size > 1024 * 300)
+                        continue; // Reduzi para 300KB para ser mais seguro
+                    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,34 @@
+#!/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')
+    .action((dir = '.', opts) => (0, sync_1.sync)(dir, !!opts.run, !!opts.dryRun, !!opts.diff));
+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,21 @@
+"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 dentro ou fora de blocos de código markdown
+    const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/;
+    const match = content.match(codeBlockRegex);
+    let cleaned = match ? match[1] : content;
+    // Remove caracteres invisíveis como BOM (Byte Order Mark) e espaços extras
+    cleaned = cleaned.trim().replace(/\uFEFF/g, "");
+    // Se ainda assim parecer que tem texto antes do array, tenta encontrar o início do array
+    if (!cleaned.startsWith("[")) {
+        const arrayStart = cleaned.indexOf("[");
+        const arrayEnd = cleaned.lastIndexOf("]");
+        if (arrayStart !== -1 && arrayEnd !== -1) {
+            cleaned = cleaned.substring(arrayStart, arrayEnd + 1);
+        }
+    }
+    return { cleaned };
+}

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.3",
-  "description": "",
+  "version": "0.4.2",
+  "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/diff": "^7.0.2",
     "@types/jest": "^29.5.3",
-    "@types/node": "^25.0.1",
+    "@types/js-yaml": "^4.0.9",
+    "@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",
+    "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"
   }
 }