johankit 0.1.5 → 1.0.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,91 @@
 // 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} ---`);
+  // 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 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");
+
+  try {
+    const content = await readClipboard();
+    if (!content) throw new Error("Clipboard empty");
+
+    const { cleaned } = cleanCodeBlock(content);
+    const items = validatePatches(JSON.parse(cleaned));
 
-        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);
+    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}`)) {
+            execSync(item.command, { stdio: 'inherit', cwd: dir });
+          }
+        }
+      } else if (item.path) {
+        if (interactiveDiff && item.content !== null) {
+          const fullPath = path.join(dir, item.path);
+          const oldContent = fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8') : "";
+          showDiff(item.path, oldContent, item.content || "");
+          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 {
-            throw new Error("JSON is neither FileSnapshot array nor DiffPatch array");
+          filePatches.push(item);
         }
+      }
+    }
 
-        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);
+    if (filePatches.length > 0) {
+      applyDiff(dir, filePatches);
     }
+
+    process.stdout.write("✔ Operation completed\n");
+  } catch (error: any) {
+    process.stderr.write(`✘ Failed: ${error.message}\n`);
+    process.exit(1);
+  }
 }

package/src/cli/commands/prompt.ts

@@ -2,81 +2,41 @@
 import { scanDir } from "../../core/scan";
 import { copyToClipboard } from "../../core/clipboard";
 
-interface LLMResponseExample {
-  type: 'FileSnapshot' | 'DiffPatch';
-  example: any;
-}
-
-export async function prompt(dir: string, userPrompt: string, diff = false) {
+export async function prompt(dir: string, userPrompt: string) {
   const snapshot = scanDir(dir);
 
-  const llmExamples: LLMResponseExample[] = [
-    {
-      type: 'FileSnapshot',
-      example: [
-        {
-          path: 'src/example.ts',
-          content: 'export const x = 42;'
-        }
-      ]
-    },
-    {
-      type: 'DiffPatch',
-      example: [
-        {
-          type: 'modify',
-          path: 'src/example.ts',
-          content: 'export const x = 43;'
-        },
-        {
-          type: 'create',
-          path: 'src/newFile.ts',
-          content: 'export const newFile = true;'
-        },
-        {
-          type: 'delete',
-          path: 'src/oldFile.ts'
-        }
-      ]
-    }
-  ];
-
   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"
-}
+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.
 ---
 
-SNAPSHOT
-${JSON.stringify(snapshot, null, 2)}
+### 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] \`\`\`
 
-YOUR TASK
-Propose changes according to the user request.
+### 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" }
 
-Return ONLY a JSON array of ${diff ? 'DiffPatch' : 'FileSnapshot'}.
+### 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.
 
-PATCH FORMAT (STRICT)
-{
-  \"path\": \"relative/path/to/file.ext\",
-  \"content\": \"FULL updated file content (omit for delete)\"
-}
+---
 
-EXAMPLE RESPONSE FROM LLM:
-${JSON.stringify(diff ? llmExamples.find(e => e.type === 'DiffPatch')?.example : llmExamples.find(e => e.type === 'FileSnapshot')?.example, null, 2)}
+SNAPSHOT
+${JSON.stringify(snapshot, null, 2)}
 
-IMPORTANT RULES
-- Do NOT return explanations
-- Do NOT return markdown
-- Return ONLY valid JSON inside the \"\`\`\`\"
-- Always return within a Markdown Code Block.
+---
 
 USER REQUEST
 ${userPrompt}
@@ -85,7 +45,7 @@ ${userPrompt}
   try {
     await copyToClipboard(template.trim());
     process.stdout.write(template.trim());
-    process.stdout.write("\n\n✔ Prompt + Snapshot + Example copied to clipboard\n");
+    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");

package/src/cli/commands/sync.ts

@@ -1,90 +1,131 @@
 // src/cli/commands/sync.ts
 import { scanDir } from "../../core/scan";
+import { validatePatches } from "../../core/schema";
 import { applyDiff } from "../../core/diff";
-import { copyToClipboard } from "../../core/clipboard";
-import { validatePatches } from "../../core/validation";
-import { writeFiles } from "../../core/write";
-
-export async function sync(dir: string, diff = false) {
-  try {
-    const snapshotBefore = 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"
+import { execSync } from "child_process";
+import cleanCodeBlock from "../../utils/cleanCodeBlock";
+import readline from "readline";
+import { copyToClipboard, readClipboard } from "../../core/clipboard";
+import fs from "fs";
+import path from "path";
+import * as diff from "diff";
+import "colors";
+
+const INTERNAL_MARKER = "__JOHANKIT_INTERNAL__";
+
+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');
+    });
+  });
 }
-\`\`\`
-
----
-
-SNAPSHOT
-${JSON.stringify(snapshotBefore, null, 2)}
-
----
 
-YOUR TASK
-Propose changes according to the user request.
+function showDiff(filename: string, oldContent: string, newContent: string) {
+  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 as any]);
+  });
+  console.log('\n-----------------------');
+}
 
-Return ONLY a JSON array of ${diff ? 'DiffPatch' : 'FileSnapshot'}.
+async function processInput(input: string, dir: string, runAll: boolean, dryRun: boolean, interactiveDiff: boolean) {
+  const autoAccept = process.argv.includes('-y');
+  const { cleaned } = cleanCodeBlock(input);
+  let patchesData;
+  
+  try {
+    patchesData = JSON.parse(cleaned);
+  } catch {
+    return false;
+  }
 
-PATCH FORMAT (STRICT)
-{
-  \"path\": \"relative/path/to/file.ext\",
-  \"content\": \"FULL updated file content (omit for delete)\"
+  const patches = 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) execSync(patch.command, { stdio: 'inherit', cwd: dir });
+      }
+    } else if (patch.path) {
+      const fullPath = path.join(dir, patch.path);
+      const exists = fs.existsSync(fullPath);
+      const oldContent = exists ? fs.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}?`)) {
+          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 {
+        applyDiff(dir, [patch]);
+      }
+    }
+  }
+  return true;
 }
 
-IMPORTANT RULES
-- Do NOT return explanations
-- Do NOT return markdown
-- Return ONLY valid JSON
+export async function sync(dir: string, runAll = false, dryRun = false, interactiveDiff = false, watch = false) {
+  try {
+    const snapshotBefore = scanDir(dir);
+    const systemPrompt = `YOU ARE AN AI SOFTWARE ENGINEER.\nALWAYS RESPOND USING ONLY A JSON PATCH ARRAY.\n\nSNAPSHOT:\n${JSON.stringify(snapshotBefore, null, 2)}`;
 
-USER REQUEST
-<Replace this with the user request>
-`;
+    await copyToClipboard(INTERNAL_MARKER + systemPrompt);
+    process.stdout.write("[johankit] System Prompt + Snapshot copied to clipboard\n");
 
-    await copyToClipboard(template.trim());
-    process.stdout.write("✔ Prompt with snapshot copied to clipboard\n");
+    if (watch) {
+      process.stdout.write("[johankit] Watching clipboard for AI response (Ctrl+C to stop)\n");
+      let lastClipboard = await readClipboard();
 
-    const input = await readStdin();
+      while (true) {
+        await new Promise(r => setTimeout(r, 1000));
+        const currentClipboard = await readClipboard();
 
-    let patches;
-    try {
-      patches = JSON.parse(input);
-    } catch {
-      throw new Error("Invalid JSON input");
-    }
+        if (!currentClipboard || currentClipboard === lastClipboard) continue;
+        lastClipboard = currentClipboard;
 
-    if (diff) {
-      const validated = validatePatches(patches);
-      applyDiff(dir, validated);
-    } else {
-      writeFiles(dir, patches as any, true);
-    }
-
-    const snapshotAfter = scanDir(dir);
-    await copyToClipboard(JSON.stringify(snapshotAfter, null, 2));
+        if (currentClipboard.startsWith(INTERNAL_MARKER)) continue;
 
-    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`);
+        const success = await processInput(currentClipboard, dir, runAll, dryRun, interactiveDiff);
+        if (success) {
+          process.stdout.write("[johankit] Patch applied from clipboard\n");
+          const snapshotAfter = scanDir(dir);
+          await copyToClipboard(INTERNAL_MARKER + JSON.stringify(snapshotAfter, null, 2));
+          process.stdout.write("[johankit] Updated snapshot copied to clipboard\n");
+        }
+      }
+    } else {
+      process.stdout.write("[johankit] Paste AI response into clipboard and press Enter\n");
+      await confirm('');
+
+      const input = await readClipboard();
+      if (!input) throw new Error("Clipboard is empty");
+
+      const success = await processInput(input, dir, runAll, dryRun, interactiveDiff);
+      if (success && !dryRun) {
+        const snapshotAfter = scanDir(dir);
+        await copyToClipboard(INTERNAL_MARKER + JSON.stringify(snapshotAfter, null, 2));
+        process.stdout.write("[johankit] Sync applied and snapshot copied to clipboard\n");
+      }
     }
+  } catch (e: any) {
+    process.stderr.write(`[johankit] Sync failed: ${e.message}\n`);
     process.exit(1);
   }
 }
-
-function readStdin(): Promise<string> {
-  return new Promise(resolve => {
-    let data = "";
-    process.stdin.on("data", c => (data += c));
-    process.stdin.on("end", () => resolve(data));
-  });
-}

package/src/core/clipboard.ts

@@ -1,94 +1,60 @@
 // src/core/clipboard.ts
 import { spawn } from "child_process";
+import clipboardy from "clipboardy";
 
-let memoryClipboard = "";
+export async function copyToClipboard(text: string): Promise<void> {
+  const platform = process.platform;
+  
+  const isWSL = process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP;
 
-export function copyToClipboard(text: string): Promise<void> {
   return new Promise((resolve, reject) => {
-    let command = "xclip";
-    let args = ["-selection", "clipboard"];
+    let command = "";
+    let args: string[] = [];
 
-    if (process.platform === "darwin") {
+    if (isWSL) {
+      command = "clip.exe";
+    } else if (platform === "darwin") {
       command = "pbcopy";
-      args = [];
-    } else if (process.platform === "win32") {
+    } else if (platform === "win32") {
       command = "clip";
-      args = [];
-    }
-
-    const child = spawn(command, args, {
-      stdio: ["pipe", "ignore", "ignore"]
-    });
-
-    let resolved = false;
-
-    child.on("error", (err) => {
-      memoryClipboard = text;
-      resolved = true;
-      resolve();
-    });
-
-    child.stdin.on("error", (err: any) => {
-      if (err.code === "EPIPE") {
-        resolved = true;
-        resolve();
-      } else {
-        memoryClipboard = text;
-        if (!resolved) resolve();
-      }
-    });
-
-    child.stdin.write(text);
-    child.stdin.end();
-
-    child.on("close", () => {
-      if (!resolved) resolve();
-    });
-  });
-}
-
-export function readClipboard(): Promise<string> {
-  return new Promise((resolve, reject) => {
-    let command: string;
-    let args: string[] = [];
-
-    if (process.platform === "darwin") {
-      command = "pbpaste";
-    } else if (process.platform === "win32") {
-      command = "powershell";
-      args = ["-Command", "Get-Clipboard"];
     } else {
       command = "xclip";
-      args = ["-selection", "clipboard", "-o"];
+      args = ["-selection", "clipboard"];
     }
 
-    const child = spawn(command, args, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-
-    let data = "";
-    let error = "";
-    let fallback = false;
-
-    child.stdout.on("data", chunk => {
-      data += chunk.toString();
-    });
-
-    child.stderr.on("data", chunk => {
-      error += chunk.toString();
-    });
-
-    child.on("error", () => {
-      fallback = true;
-      resolve(memoryClipboard);
-    });
-
-    child.on("close", code => {
-      if (code !== 0 || fallback) {
-        resolve(memoryClipboard);
-      } else {
-        resolve(data);
-      }
-    });
+    try {
+      const child = 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);
+    }
   });
 }
+
+export async function readClipboard(): Promise<string> {
+  try {
+    return await clipboardy.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 = spawn(command, args);
+      let output = "";
+
+      child.stdout.on("data", (d) => (output += d.toString()));
+      child.on("close", () => resolve(output.trim()));
+      child.on("error", () => resolve(""));
+    });
+  }
+}