johankit 0.1.3 → 1.0.0

package/README.md

@@ -1,89 +1,81 @@
 # JohanKit
 
-**JohanKit** is a developer-friendly CLI designed to supercharge your **vibe-coding** flow. It helps you capture, restore, and manipulate snapshots of your codebase, making it effortless to experiment, refactor, and collaborate—without locking you into a specific framework or workflow.
+**JohanKit** is a developer-friendly CLI for capturing, restoring, and applying codebase snapshots — perfect for vibe-coding with AI.
 
-Think of it as your personal **code snapshot toolkit**: lightweight, fast, and agnostic.
-
----
-
-## Why JohanKit?
-
-JohanKit is a “kit for developers,” crafted to streamline coding sessions, prototype features quickly, and integrate seamlessly with AI-assisted refactoring or review tools.
-
----
+Lightweight, fast, platform-agnostic.
 
 ## Features
 
 ### copy
-
-Take a snapshot of files in a directory and copy it to your clipboard as JSON.
+Capture directory snapshot as JSON array to clipboard.
 
 ```bash
-johankit copy <dir> [exts]
-````
-
-* `dir`: Directory to scan (default: current)
-* `exts`: Comma-separated list of extensions (e.g., `ts,js`)
+johankit copy [dir] [exts]
+```
 
----
+**Example:**
+```bash
+johankit copy src ts,tsx,js,jsx
+```
 
 ### paste
-
-Restore files from a JSON snapshot stored in your clipboard.
+Apply patches from JSON clipboard content.
 
 ```bash
-johankit paste <dir>
+johankit paste [dir] [--run] [--diff] [--dry-run] [-y]
 ```
 
-* `dir`: Directory where files will be created (default: current)
-
----
+**Examples:**
+```bash
+johankit paste src --dry-run          # Preview only
+johankit paste src --diff             # Interactive diff review
+johankit paste src --run -y           # Auto-apply + run commands
+```
 
 ### prompt
-
-Generate a ready-to-use AI prompt including a snapshot of your codebase.
+Generate AI-ready prompt with snapshot + your request.
 
 ```bash
-johankit prompt <dir> "<user request>"
+johankit prompt [dir] "<request>"
 ```
 
-* `dir`: Directory to scan (default: current)
-* `<user request>`: Instruction for AI to apply on the snapshot
-
----
+**Example:**
+```bash
+johankit prompt src "Add Zod validation to all API routes"
+```
 
 ### sync
-
-Apply JSON patches to your codebase and update the clipboard with the new snapshot.
+Iterative AI workflow: snapshot → paste patch → new snapshot.
 
 ```bash
-johankit sync <dir>
+johankit sync [dir] [--run] [--diff] [--dry-run] [--watch] [--auto]
 ```
 
-* `dir`: Target directory (default: current)
-
----
+**Examples:**
+```bash
+johankit sync src --auto              # Watch clipboard + auto-apply
+johankit sync src --diff --run        # Interactive + execute commands
+```
 
-## Example Workflow
+## Quick Workflow Example
 
 ```bash
-# Copy snapshot of your current src
-johankit copy src
+# 1. Generate prompt
+johankit prompt src "Refactor auth middleware to use JWT"
 
-# Ask AI to refactor your codebase
-johankit prompt src "Convert all callbacks to async/await"
+# 2. Paste into LLM → copy JSON patch back to clipboard
 
-# Apply AI-suggested changes and update snapshot
-johankit sync src
+# 3. Apply with review
+johankit paste src --diff
 ```
 
-With just a few commands, JohanKit lets you **capture ideas, experiment safely, and sync changes instantly**.
-
----
-
-## Configuration
+Or fast loop:
+```bash
+johankit sync src --auto
+```
 
-You can configure defaults with a `johankit.yaml` file in the project root:
+## Config
+Create `johankit.yml` in project root:
 
 ```yaml
 ignore:
@@ -92,19 +84,10 @@ ignore:
   - .git
 ```
 
-This ensures you never accidentally snapshot unnecessary files.
-
----
-
-## Requirements
+Also respects `.gitignore`.
 
-* Node.js >= 14
-* Clipboard-compatible OS (`xclip`, `pbcopy`, or `clip` on Windows)
-
----
-
-## Installation
+## Install
 
 ```bash
 npm install -g johankit
-```
+```

package/dist/cli/commands/sync.js

@@ -1,84 +1,63 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sync = void 0;
+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 clipboard_1 = require("../../core/clipboard");
-const validation_1 = require("../../core/validation");
-const write_1 = require("../../core/write");
-async function sync(dir, diff = false) {
+const child_process_1 = require("child_process");
+const cleanCodeBlock_1 = __importDefault(require("../../utils/cleanCodeBlock"));
+const readline_1 = __importDefault(require("readline"));
+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');
+        });
+    });
+}
+async function sync(dir, runAll = false) {
+    const autoAccept = process.argv.includes("-y");
     try {
         const snapshotBefore = (0, scan_1.scanDir)(dir);
         const template = `
-You are an AI software engineer.
-
-You will receive a JSON array representing a snapshot of a codebase.
-Each item has the following structure:
-
-\`\`\`json
-{
-  "path": "relative/path/to/file.ext",
-  "content": "full file content"
-}
-\`\`\`
-
----
-
-SNAPSHOT
+// ... (template mantido) ...
 ${JSON.stringify(snapshotBefore, null, 2)}
-
----
-
-YOUR TASK
-Propose changes according to the user request.
-
-Return ONLY a JSON array of ${diff ? 'DiffPatch' : 'FileSnapshot'}.
-
-PATCH FORMAT (STRICT)
-{
-  \"path\": \"relative/path/to/file.ext\",
-  \"content\": \"FULL updated file content (omit for delete)\"
-}
-
-IMPORTANT RULES
-- Do NOT return explanations
-- Do NOT return markdown
-- Return ONLY valid JSON
-
-USER REQUEST
-<Replace this with the user request>
 `;
         await (0, clipboard_1.copyToClipboard)(template.trim());
-        process.stdout.write("✔ Prompt with snapshot copied to clipboard\n");
+        process.stdout.write("✔ Prompt with snapshot copied to clipboard. Paste the response here and press Enter (Ctrl+D to finish):\n");
         const input = await readStdin();
-        let patches;
-        try {
-            patches = JSON.parse(input);
-        }
-        catch {
-            throw new Error("Invalid JSON input");
-        }
-        if (diff) {
-            const validated = (0, validation_1.validatePatches)(patches);
-            (0, diff_1.applyDiff)(dir, validated);
-        }
-        else {
-            (0, write_1.writeFiles)(dir, patches, true);
+        const { cleaned } = (0, cleanCodeBlock_1.default)(input);
+        const patches = (0, schema_1.validatePatches)(JSON.parse(cleaned));
+        for (const patch of patches) {
+            if (patch.type === 'console' && patch.command) {
+                if (runAll) {
+                    const shouldRun = autoAccept || await confirm(`> Execute: ${patch.command}`);
+                    if (shouldRun)
+                        (0, child_process_1.execSync)(patch.command, { stdio: 'inherit', cwd: dir });
+                }
+                else {
+                    console.log(`> Skipped command: ${patch.command} (use --run)`);
+                }
+            }
+            else if (patch.path) {
+                (0, diff_1.applyDiff)(dir, [patch]);
+            }
         }
         const snapshotAfter = (0, scan_1.scanDir)(dir);
         await (0, clipboard_1.copyToClipboard)(JSON.stringify(snapshotAfter, null, 2));
         process.stdout.write("✔ Sync applied and new snapshot copied to clipboard\n");
     }
     catch (error) {
-        process.stderr.write("✖ Sync failed\n");
-        if (error instanceof Error) {
-            process.stderr.write(`${error.message}\n`);
-        }
+        process.stderr.write(`✖ Sync failed: ${error.message}\n`);
         process.exit(1);
     }
 }
-exports.sync = sync;
 function readStdin() {
     return new Promise(resolve => {
         let data = "";

package/dist/core/validation.js

@@ -1,24 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePatches = void 0;
+exports.validatePatches = validatePatches;
+// src/core/validation.ts
+const schema_1 = require("./schema");
+/**
+ * @deprecated Use validatePatches from core/schema instead.
+ */
 function validatePatches(json) {
-    if (!Array.isArray(json)) {
-        throw new Error("Validation Error: Input is not a JSON array.");
-    }
-    return json.map((item, index) => {
-        if (typeof item !== "object" || item === null) {
-            throw new Error(`Validation Error: Item at index ${index} is not an object.`);
-        }
-        if (!["modify", "create", "delete"].includes(item.type)) {
-            throw new Error(`Validation Error: Invalid type '${item.type}' at index ${index}.`);
-        }
-        if (typeof item.path !== "string" || !item.path.trim()) {
-            throw new Error(`Validation Error: Invalid or missing path at index ${index}.`);
-        }
-        if (item.type !== "delete" && typeof item.content !== "string") {
-            throw new Error(`Validation Error: Missing content for '${item.type}' at index ${index}.`);
-        }
-        return item;
-    });
+    return (0, schema_1.validatePatches)(json);
 }
-exports.validatePatches = validatePatches;

package/dist/core/write.js

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copy = copy;
+const scan_1 = require("../../core/scan");
+const clipboard_1 = require("../../core/clipboard");
+async function copy(dir, extensions) {
+    const snapshot = (0, scan_1.scanDir)(dir, { extensions });
+    const clipboardJSON = JSON.stringify(snapshot);
+    await (0, clipboard_1.copyToClipboard)(clipboardJSON);
+    process.stdout.write(`✔ Snapshot de ${dir} copiado (${(clipboardJSON.length / 1024).toFixed(2)} KB)\n`);
+}

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

@@ -0,0 +1,128 @@
+"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.paste = paste;
+// src/cli/commands/paste.ts
+const diff_1 = require("../../core/diff");
+const clipboard_1 = require("../../core/clipboard");
+const schema_1 = require("../../core/schema");
+const cleanCodeBlock_1 = __importDefault(require("../../utils/cleanCodeBlock"));
+const child_process_1 = require("child_process");
+const readline_1 = __importDefault(require("readline"));
+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} ---`);
+    // Otimização: Usar diffLines apenas se o conteúdo for diferente para evitar processamento inútil
+    if (oldContent === newContent) {
+        console.log("No changes detected.".gray);
+        return;
+    }
+    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 paste(dir, runAll = false, dryRun = false, interactiveDiff = false) {
+    const autoAccept = process.argv.includes("-y");
+    try {
+        const content = await (0, clipboard_1.readClipboard)();
+        if (!content)
+            throw new Error("Clipboard empty");
+        const { cleaned } = (0, cleanCodeBlock_1.default)(content);
+        const items = (0, schema_1.validatePatches)(JSON.parse(cleaned));
+        if (dryRun)
+            process.stdout.write("--- DRY RUN MODE ---\n");
+        // Otimização: Agrupar patches de arquivos para aplicar de uma vez se não for interativo
+        const filePatches = [];
+        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}`)) {
+                        (0, child_process_1.execSync)(item.command, { stdio: 'inherit', cwd: dir });
+                    }
+                }
+            }
+            else if (item.path) {
+                if (interactiveDiff && item.content !== null) {
+                    const fullPath = path_1.default.join(dir, item.path);
+                    const oldContent = fs_1.default.existsSync(fullPath) ? fs_1.default.readFileSync(fullPath, 'utf8') : "";
+                    showDiff(item.path, oldContent, item.content || "");
+                    if (await confirm(`Apply changes to ${item.path}?`)) {
+                        (0, diff_1.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 {
+                    filePatches.push(item);
+                }
+            }
+        }
+        if (filePatches.length > 0) {
+            (0, diff_1.applyDiff)(dir, filePatches);
+        }
+        process.stdout.write("✔ Operation completed\n");
+    }
+    catch (error) {
+        process.stderr.write(`✘ Failed: ${error.message}\n`);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = prompt;
+// src/cli/commands/prompt.ts
+const scan_1 = require("../../core/scan");
+const clipboard_1 = require("../../core/clipboard");
+async function prompt(dir, userPrompt) {
+    const snapshot = (0, scan_1.scanDir)(dir);
+    const template = `
+You are an AI software engineer. 
+Your goal is to help the user with their codebase using a specific JSON patch format.
+
+Maintain 100% of previous functionality for full compatibility.
+Always submit the complete code; never use comments.
+Use "git add {files} && git commit -m {message}" after each change via the console.
+---
+
+### CAPABILITIES
+1. **File Updates**: You can create, update, or delete files.
+2. **Console Commands**: You can execute shell commands (e.g., npm install, mkdir, rm, vitest).
+
+### RESPONSE FORMAT
+Return ONLY a JSON array. No conversational text. No explanations.
+Wrap the JSON in a markdown code block: \`\`\`json [your_array] \`\`\`
+
+### PATCH TYPES
+- **File Patch**: { "path": "src/file.ts", "content": "full code" }
+- **Delete File**: { "path": "src/old-file.ts", "content": null }
+- **Console**: { "type": "console", "command": "npm install lodash" }
+
+### STRATEGY
+If the user request requires a new library, include the "npm install" command in the array before the file updates.
+If the user wants to refactor and ensure it works, you can include a command to run tests.
+
+---
+
+SNAPSHOT
+${JSON.stringify(snapshot, null, 2)}
+
+---
+
+USER REQUEST
+${userPrompt}
+`;
+    try {
+        await (0, clipboard_1.copyToClipboard)(template.trim());
+        process.stdout.write(template.trim());
+        process.stdout.write("\n\n✔ Prompt + Snapshot copied to clipboard\n");
+    }
+    catch (e) {
+        process.stdout.write(template.trim());
+        process.stderr.write("\n✖ Failed to copy to clipboard (output only)\n");
+    }
+}