johankit 0.1.5 → 0.4.2

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

@@ -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,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.5",
-  "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/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",
+    "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"
   }
 }

package/src/cli/commands/copy.ts

@@ -1,23 +1,10 @@
 import { scanDir } from "../../core/scan";
 import { copyToClipboard } from "../../core/clipboard";
 
-export async function copy(input: string | string[]) {
-  let snapshot: any[] = [];
+export async function copy(dir: string, extensions?: string[]) {
+  const snapshot = scanDir(dir, { extensions });
+  const clipboardJSON = JSON.stringify(snapshot);
+  await copyToClipboard(clipboardJSON);
 
-  const paths = Array.isArray(input) ? input : [input];
-
-  for (const p of paths) {
-    const scanned = scanDir(p);
-    snapshot.push(...scanned);
-  }
-
-  const clipboardJSON = JSON.stringify(snapshot, null, 2);
-
-  try {
-    await copyToClipboard(clipboardJSON);
-  } catch (err) {
-    console.warn("Clipboard unavailable:", err);
-  }
-
-  return clipboardJSON;
-}
+  process.stdout.write(`✔ Snapshot de ${dir} copiado (${(clipboardJSON.length / 1024).toFixed(2)} KB)\n`);
+}

package/src/cli/commands/paste.ts

@@ -1,43 +1,82 @@
 // src/cli/commands/paste.ts
-import { writeFiles } from "../../core/write";
+import { applyDiff } from "../../core/diff";
 import { readClipboard } from "../../core/clipboard";
+import { validatePatches } from "../../core/schema";
 import cleanCodeBlock from "../../utils/cleanCodeBlock";
-import { applyDiff } from "../../core/diff";
-import { validatePatches } from "../../core/validation";
+import { execSync } from "child_process";
+import readline from "readline";
+import fs from "fs";
+import path from "path";
+import * as diff from "diff";
+import "colors";
 
-export async function paste(dir: string) {
-    try {
-        const content = await readClipboard();
+async function confirm(msg: string): Promise<boolean> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(`${msg} (y/N): `, (ans) => {
+      rl.close();
+      resolve(ans.toLowerCase() === 'y');
+    });
+  });
+}
 
-        if (!content) {
-            throw new Error("Clipboard empty or inaccessible");
-        }
+function showDiff(filename: string, oldContent: string, newContent: string) {
+  console.log(`\n--- DIFF FOR: ${filename.bold} ---`);
+  const patches = diff.diffLines(oldContent, newContent);
+  patches.forEach((part: diff.Change) => {
+    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: string) => line ? `${prefix}${line}` : '').join('\n'))[color as any]);
+  });
+  console.log('\n-----------------------');
+}
 
-        let parsed;
-        try {
-            const { cleaned } = cleanCodeBlock(content);
-            parsed = JSON.parse(cleaned);
-        } catch (e) {
-            throw new Error("Clipboard content is not valid JSON");
-        }
+export async function paste(dir: string, runAll = false, dryRun = false, interactiveDiff = false) {
+  const autoAccept = process.argv.includes("-y");
 
-        if (Array.isArray(parsed) && parsed.every(f => f.path && f.content)) {
-            // Caso seja snapshot
-            writeFiles(dir, parsed, true);
-        } else if (Array.isArray(parsed) && parsed.every(f => f.type && f.path)) {
-            // Caso seja DiffPatch
-            const validated = validatePatches(parsed);
-            applyDiff(dir, validated);
-        } else {
-            throw new Error("JSON is neither FileSnapshot array nor DiffPatch array");
+  try {
+    const content = await readClipboard();
+    if (!content) throw new Error("Clipboard empty");
+
+    const { cleaned } = cleanCodeBlock(content);
+    const items = validatePatches(JSON.parse(cleaned));
+
+    if (dryRun) process.stdout.write("--- DRY RUN MODE ---\n");
+
+    for (const item of items) {
+      if (item.type === 'console' && item.command) {
+        if (dryRun) {
+          process.stdout.write(`[DRY-RUN] Would execute: ${item.command}\n`);
+        } else if (runAll) {
+          if (autoAccept || await confirm(`> Execute: ${item.command}`)) {
+            execSync(item.command, { stdio: 'inherit', cwd: dir });
+          }
         }
+      } else if (item.path) {
+        const fullPath = path.join(dir, item.path);
+        const exists = fs.existsSync(fullPath);
+        const oldContent = exists ? fs.readFileSync(fullPath, 'utf8') : "";
+        const newContent = item.content || "";
 
-        process.stdout.write("✔ Pasted from clipboard\n");
-    } catch (error) {
-        process.stderr.write("✖ Paste failed\n");
-        if (error instanceof Error) {
-            process.stderr.write(`${error.message}\n`);
+        if (interactiveDiff && item.content !== null) {
+          showDiff(item.path, oldContent, newContent);
+          if (await confirm(`Apply changes to ${item.path}?`)) {
+            applyDiff(dir, [item]);
+          } else {
+            console.log(`Skipped: ${item.path}`);
+          }
+        } else if (dryRun) {
+          process.stdout.write(`[DRY-RUN] Would ${item.content === null ? 'Delete' : 'Write'}: ${item.path}\n`);
+        } else {
+          applyDiff(dir, [item]);
         }
-        process.exit(1);
+      }
     }
+
+    process.stdout.write("√ Operation completed\n");
+  } catch (error: any) {
+    process.stderr.write(`× Failed: ${error.message}\n`);
+    process.exit(1);
+  }
 }