johankit 0.0.2

package/README.md

@@ -0,0 +1,115 @@
+# 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.
+
+Think of it as your personal **code snapshot toolkit**: lightweight, fast, and agnostic.
+
+---
+
+## Why JohanKit?
+
+The name combines:
+
+- **Johan** – a nod to the “creator” or developer archetype.
+- **Kit** – a set of practical tools.
+
+JohanKit is a “kit for developers,” crafted to streamline coding sessions, prototype features quickly, and integrate seamlessly with AI-assisted refactoring or review tools.
+
+---
+
+## Features
+
+### copy
+
+Take a snapshot of files in a directory and copy it to your clipboard as JSON.
+
+```bash
+johankit copy <dir> [exts]
+````
+
+* `dir`: Directory to scan (default: current)
+* `exts`: Comma-separated list of extensions (e.g., `ts,js`)
+
+---
+
+### paste
+
+Restore files from a JSON snapshot stored in your clipboard.
+
+```bash
+johankit paste <dir>
+```
+
+* `dir`: Directory where files will be created (default: current)
+
+---
+
+### prompt
+
+Generate a ready-to-use AI prompt including a snapshot of your codebase.
+
+```bash
+johankit prompt <dir> "<user request>"
+```
+
+* `dir`: Directory to scan (default: current)
+* `<user request>`: Instruction for AI to apply on the snapshot
+
+---
+
+### sync
+
+Apply JSON patches to your codebase and update the clipboard with the new snapshot.
+
+```bash
+johankit sync <dir>
+```
+
+* `dir`: Target directory (default: current)
+
+---
+
+## Example Workflow
+
+```bash
+# Copy snapshot of your current src
+johankit copy src
+
+# Ask AI to refactor your codebase
+johankit prompt src "Convert all callbacks to async/await"
+
+# Apply AI-suggested changes and update snapshot
+johankit sync src
+```
+
+With just a few commands, JohanKit lets you **capture ideas, experiment safely, and sync changes instantly**.
+
+---
+
+## Configuration
+
+You can configure defaults with a `johankit.yaml` file in the project root:
+
+```yaml
+ignore:
+  - dist
+  - node_modules
+  - .git
+```
+
+This ensures you never accidentally snapshot unnecessary files.
+
+---
+
+## Requirements
+
+* Node.js >= 14
+* Clipboard-compatible OS (`xclip`, `pbcopy`, or `clip` on Windows)
+
+---
+
+## Installation
+
+```bash
+npm install -g johankit
+```

package/dist/cli/commands/copy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copy = void 0;
+const scan_1 = require("../../core/scan");
+const clipboard_1 = require("../../core/clipboard");
+function copy(input) {
+    let snapshot;
+    if (Array.isArray(input)) {
+        snapshot = input.map(path => {
+            const fileSnapshot = (0, scan_1.scanDir)(path);
+            if (fileSnapshot.length !== 1) {
+                throw new Error(`Expected single file for path: ${path}`);
+            }
+            return fileSnapshot[0];
+        });
+    }
+    else {
+        const stat = (0, scan_1.scanDir)(input);
+        snapshot = stat.length === 1 ? stat : (0, scan_1.scanDir)(input);
+    }
+    const clipboardJSON = JSON.stringify(snapshot, null, 2); // <- garante JSON válido
+    (0, clipboard_1.copyToClipboard)(clipboardJSON);
+}
+exports.copy = copy;

package/dist/cli/commands/paste.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paste = void 0;
+// src/cli/commands/paste.ts
+const write_1 = require("../../core/write");
+const clipboard_1 = require("../../core/clipboard");
+async function paste(dir) {
+    try {
+        const content = await (0, clipboard_1.readClipboard)();
+        if (!content) {
+            throw new Error("Clipboard empty or inaccessible");
+        }
+        let files;
+        try {
+            const cleanContent = content.replace(/^\uFEFF/, "").trim();
+            files = JSON.parse(cleanContent);
+        }
+        catch (e) {
+            throw new Error("Clipboard content is not valid JSON");
+        }
+        if (!Array.isArray(files)) {
+            throw new Error("Clipboard content is not a JSON array");
+        }
+        // Validação simples do snapshot
+        const isValidSnapshot = files.every(f => typeof f.path === 'string' && typeof f.content === 'string');
+        if (!isValidSnapshot) {
+            throw new Error("JSON does not match FileSnapshot structure {path, content}");
+        }
+        (0, write_1.writeFiles)(dir, files, true);
+        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`);
+        }
+        process.exit(1);
+    }
+}
+exports.paste = paste;

package/dist/cli/commands/prompt.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = void 0;
+// 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.
+
+You will receive a JSON array representing a snapshot of a codebase.
+Each item has the following structure:
+
+{
+  "path": "relative/path/to/file.ext",
+  "content": "full file content"
+}
+
+---
+
+SNAPSHOT
+${JSON.stringify(snapshot, null, 2)}
+
+---
+
+YOUR TASK
+Propose changes according to the user request.
+
+Return ONLY a JSON array of patches.
+
+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 inside the "\`\`\`"
+- Always return within a Markdown Code Block (with "\`\`\`json" syntax highlighting)")
+
+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");
+    }
+}
+exports.prompt = prompt;

package/dist/cli/commands/sync.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sync = void 0;
+// src/cli/commands/sync.ts
+const scan_1 = require("../../core/scan");
+const diff_1 = require("../../core/diff");
+const clipboard_1 = require("../../core/clipboard");
+const validation_1 = require("../../core/validation");
+async function sync(dir) {
+    try {
+        const snapshotBefore = (0, scan_1.scanDir)(dir);
+        // Gera prompt genérico para AI com snapshot atual
+        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
+${JSON.stringify(snapshotBefore, null, 2)}
+
+---
+
+YOUR TASK
+Propose changes according to the user request.
+
+Return ONLY a JSON array of patches.
+
+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");
+        // Aguarda entrada do usuário (resposta da AI) via stdin
+        const input = await readStdin();
+        let patches;
+        try {
+            patches = JSON.parse(input);
+        }
+        catch {
+            throw new Error("Invalid JSON input");
+        }
+        const validated = (0, validation_1.validatePatches)(patches);
+        (0, diff_1.applyDiff)(dir, validated);
+        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.exit(1);
+    }
+}
+exports.sync = sync;
+function readStdin() {
+    return new Promise(resolve => {
+        let data = "";
+        process.stdin.on("data", c => (data += c));
+        process.stdin.on("end", () => resolve(data));
+    });
+}

package/dist/core/clipboard.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClipboard = exports.copyToClipboard = void 0;
+// src/core/clipboard.ts
+const child_process_1 = require("child_process");
+function copyToClipboard(text) {
+    return new Promise((resolve, reject) => {
+        let command = "xclip";
+        let args = ["-selection", "clipboard"];
+        if (process.platform === "darwin") {
+            command = "pbcopy";
+            args = [];
+        }
+        else if (process.platform === "win32") {
+            command = "clip";
+            args = [];
+        }
+        const child = (0, child_process_1.spawn)(command, args, { stdio: ["pipe", "ignore", "ignore"] });
+        child.on("error", (err) => reject(err));
+        child.on("close", () => resolve());
+        child.stdin.write(text);
+        child.stdin.end();
+    });
+}
+exports.copyToClipboard = copyToClipboard;
+function readClipboard() {
+    return new Promise((resolve, reject) => {
+        let command = "xclip";
+        let args = ["-selection", "clipboard", "-o"];
+        if (process.platform === "darwin") {
+            command = "pbpaste";
+            args = [];
+        }
+        else if (process.platform === "win32") {
+            command = "powershell";
+            args = ["-command", "Get-Clipboard"];
+        }
+        const child = (0, child_process_1.spawn)(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        let error = "";
+        child.stdout.on("data", (d) => (output += d.toString()));
+        child.stderr.on("data", (d) => (error += d.toString()));
+        child.on("error", (err) => reject(err));
+        child.on("close", (code) => {
+            if (code !== 0 && error && !output) {
+                reject(new Error(error || "Clipboard read failed"));
+            }
+            else {
+                resolve(output.trim().replace(/^\uFEFF/, ""));
+            }
+        });
+    });
+}
+exports.readClipboard = readClipboard;

package/dist/core/config.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = void 0;
+// src/core/config.ts
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const js_yaml_1 = require("js-yaml");
+const CONFIG_FILENAME = "johankit.yaml";
+const DEFAULT_IGNORE = [
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "tmp",
+    "temp",
+];
+/**
+ * Tenta carregar as configurações do arquivo johankit.yaml na basePath.
+ * Retorna um objeto Config com defaults se o arquivo não for encontrado.
+ * @param basePath O diretório base para procurar o arquivo de configuração.
+ * @returns O objeto de configuração.
+ */
+function loadConfig(basePath) {
+    const configPath = path_1.default.join(basePath, CONFIG_FILENAME);
+    try {
+        const content = (0, fs_1.readFileSync)(configPath, "utf8");
+        const loadedConfig = (0, js_yaml_1.load)(content);
+        return {
+            ignore: [
+                ...DEFAULT_IGNORE,
+                ...(loadedConfig.ignore || []),
+            ],
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.code === "ENOENT") {
+            // Arquivo não encontrado, retorna configuração padrão
+            return {
+                ignore: DEFAULT_IGNORE,
+            };
+        }
+        console.warn(`[johankit] Aviso: Falha ao carregar ${CONFIG_FILENAME}. Usando defaults.`, error);
+        return {
+            ignore: DEFAULT_IGNORE,
+        };
+    }
+}
+exports.loadConfig = loadConfig;

package/dist/core/diff.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDiff = void 0;
+// 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) {
+        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;
+            }
+        }
+    }
+}
+exports.applyDiff = applyDiff;

package/dist/core/git.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureGitCommit = void 0;
+// src/core/git.ts
+const child_process_1 = require("child_process");
+const crypto_1 = __importDefault(require("crypto"));
+function getDiffHash() {
+    try {
+        const diff = (0, child_process_1.execSync)("git diff --staged", { encoding: "utf8" });
+        if (!diff.trim())
+            return null;
+        return crypto_1.default
+            .createHash("sha1")
+            .update(diff)
+            .digest("hex")
+            .slice(0, 7);
+    }
+    catch {
+        return null;
+    }
+}
+function defaultCommitMessage(prefix = "Auto Commit") {
+    const timestamp = new Date().toISOString().slice(0, 16);
+    const diffHash = getDiffHash();
+    return diffHash
+        ? `${prefix}: ${timestamp} · ${diffHash}`
+        : `${prefix}: ${timestamp}`;
+}
+function ensureGitCommit(message) {
+    try {
+        (0, child_process_1.execSync)("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+        (0, child_process_1.execSync)("git add .");
+        const commitMessage = message ?? defaultCommitMessage();
+        (0, child_process_1.execSync)(`git commit -m "${commitMessage}"`, { stdio: "ignore" });
+    }
+    catch {
+        // noop: no git or nothing to commit
+    }
+}
+exports.ensureGitCommit = ensureGitCommit;

package/dist/core/scan.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanDir = void 0;
+// src/core/scan.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function scanDir(basePath, options = {}) {
+    const result = [];
+    const base = path_1.default.resolve(basePath);
+    const exts = options.extensions?.map(e => e.startsWith(".") ? e : `.${e}`);
+    // Default ignores
+    const ignoreSet = new Set([
+        "node_modules", ".git", "dist", "build", ".DS_Store", "coverage", ".env", "yarn.lock",
+    ]);
+    // Read .gitignore if exists
+    const gitignorePath = path_1.default.join(base, ".gitignore");
+    if (fs_1.default.existsSync(gitignorePath)) {
+        try {
+            const lines = fs_1.default.readFileSync(gitignorePath, "utf8").split("\n");
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith("#")) {
+                    ignoreSet.add(trimmed.replace(/^\//, "").replace(/\/$/, ""));
+                }
+            }
+        }
+        catch (e) {
+            // ignore read errors
+        }
+    }
+    function shouldIgnore(name) {
+        if (ignoreSet.has(name))
+            return true;
+        for (const pattern of ignoreSet) {
+            if (pattern.startsWith("*") && name.endsWith(pattern.slice(1)))
+                return true;
+            if (name.startsWith(pattern + "/"))
+                return true;
+        }
+        return false;
+    }
+    function loop(currentPath) {
+        const entries = fs_1.default.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (shouldIgnore(entry.name))
+                continue;
+            const fullPath = path_1.default.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                loop(fullPath);
+            }
+            else {
+                if (exts && !exts.includes(path_1.default.extname(entry.name)))
+                    continue;
+                result.push({
+                    path: path_1.default.relative(base, fullPath).replace(/\\/g, "/"),
+                    content: fs_1.default.readFileSync(fullPath, "utf8"),
+                });
+            }
+        }
+    }
+    loop(base);
+    return result;
+}
+exports.scanDir = scanDir;

package/dist/core/schema.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePatches = void 0;
+/**
+ * Valida se um objeto se parece com um Patch de DiffPatch válido.
+ * Não faz validação completa de esquema (JSON Schema), mas verifica a estrutura básica.
+ */
+function isValidPatch(patch) {
+    if (typeof patch !== "object" || patch === null)
+        return false;
+    if (typeof patch.path !== "string" || patch.path.length === 0)
+        return false;
+    const validTypes = ["modify", "create", "delete"];
+    if (!validTypes.includes(patch.type))
+        return false;
+    if (patch.type === "delete") {
+        return patch.content === undefined;
+    }
+    else {
+        return typeof patch.content === "string";
+    }
+}
+/**
+ * Valida um array de patches de diff (DiffPatch[]).
+ * @param patches O array a ser validado.
+ * @returns O array de patches se for válido.
+ * @throws Um erro se a validação falhar.
+ */
+function validatePatches(patches) {
+    if (!Array.isArray(patches)) {
+        throw new Error("O patch deve ser um array JSON válido");
+    }
+    for (const [index, patch] of patches.entries()) {
+        if (!isValidPatch(patch)) {
+            throw new Error(`Patch inválido no índice ${index}: ${JSON.stringify(patch, null, 2)}.\nEsperado: { type: 'modify'|'create'|'delete', path: string, content?: string }`);
+        }
+    }
+    // Assume que o array validado está no formato correto de DiffPatch[]
+    return patches;
+}
+exports.validatePatches = validatePatches;

package/dist/core/validation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePatches = void 0;
+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;
+    });
+}
+exports.validatePatches = validatePatches;

package/dist/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 = void 0;
+// src/core/write.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const git_1 = require("./git");
+function writeFiles(basePath, files, commit = true) {
+    if (commit) {
+        (0, git_1.ensureGitCommit)("johankit: before paste");
+    }
+    for (const file of files) {
+        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");
+    }
+}
+exports.writeFiles = writeFiles;