johankit 0.1.5 → 0.4.2

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,138 @@
 // 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";
+
+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.
-
-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)\"
+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-----------------------');
 }
 
-IMPORTANT RULES
-- Do NOT return explanations
-- Do NOT return markdown
-- Return ONLY valid JSON
+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 (e) {
+    return false;
+  }
 
-USER REQUEST
-<Replace this with the user request>
-`;
+  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;
+}
 
-    await copyToClipboard(template.trim());
-    process.stdout.write("✔ Prompt with snapshot copied to clipboard\n");
+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.
+ALWAYS RESPOND USING THE FOLLOWING JSON PATCH FORMAT ONLY.
 
-    const input = await readStdin();
+FORMAT:
+[{"path": "file.ts", "content": "full code"}, {"type": "console", "command": "npm install"}]
 
-    let patches;
-    try {
-      patches = JSON.parse(input);
-    } catch {
-      throw new Error("Invalid JSON input");
-    }
+SNAPSHOT:
+${JSON.stringify(snapshotBefore, null, 2)}
 
-    if (diff) {
-      const validated = validatePatches(patches);
-      applyDiff(dir, validated);
+PLEASE APPLY THE USER REQUESTS TO THIS SNAPSHOT AND RETURN ONLY THE JSON ARRAY.`;
+
+    await 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 readClipboard();
+      
+      while (true) {
+        await new Promise(r => setTimeout(r, 1000));
+        const currentClipboard = await 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 = scanDir(dir);
+            await copyToClipboard(JSON.stringify(snapshotAfter, null, 2));
+            process.stdout.write('√ Updated snapshot copied to clipboard. Ready for next turn.\n');
+          }
+        }
+      }
     } else {
-      writeFiles(dir, patches as any, true);
-    }
-
-    const snapshotAfter = scanDir(dir);
-    await 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.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 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(JSON.stringify(snapshotAfter, null, 2));
+        process.stdout.write('√ Sync applied! Updated snapshot is now in your clipboard.\n');
+      }
     }
+  } catch (e: any) {
+    process.stderr.write(`× 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(""));
+    });
+  }
+}

package/src/core/config.ts

@@ -1,10 +1,8 @@
-// src/core/config.ts
 import path from "path";
-import { readFileSync } from "fs";
+import { readFileSync, existsSync } from "fs";
 import { load } from "js-yaml";
 import { Config } from "../types";
 
-const CONFIG_FILENAME = "johankit.yaml";
 const DEFAULT_IGNORE = [
   ".git",
   "node_modules",
@@ -15,36 +13,26 @@ const DEFAULT_IGNORE = [
   "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.
- */
 export function loadConfig(basePath: string): Config {
-  const configPath = path.join(basePath, CONFIG_FILENAME);
+  const configFilenames = ["johankit.yaml", "johankit.yml"];
+  let loadedConfig: Partial<Config> = {};
 
-  try {
-    const content = readFileSync(configPath, "utf8");
-    const loadedConfig = load(content) as Partial<Config>;
-
-    return {
-      ignore: [
-        ...DEFAULT_IGNORE,
-        ...(loadedConfig.ignore || []),
-      ],
-    };
-  } catch (error) {
-    if (error instanceof Error && (error as any).code === "ENOENT") {
-      // Arquivo não encontrado, retorna configuração padrão
-      return {
-        ignore: DEFAULT_IGNORE,
-      };
+  for (const filename of configFilenames) {
+    const configPath = path.join(basePath, filename);
+    if (existsSync(configPath)) {
+      try {
+        const content = readFileSync(configPath, "utf8");
+        loadedConfig = (load(content) as Partial<Config>) || {};
+        break;
+      } catch (error) {
+        console.warn(`[johankit] Erro ao ler ${filename}, tentando próximo...`);
+      }
     }
-
-    console.warn(`[johankit] Aviso: Falha ao carregar ${CONFIG_FILENAME}. Usando defaults.`, error);
-    return {
-      ignore: DEFAULT_IGNORE,
-    };
   }
-}
+
+  const ignoreSet = new Set([...DEFAULT_IGNORE, ...(loadedConfig.ignore || [])]);
+
+  return {
+    ignore: Array.from(ignoreSet),
+  };
+}

package/src/core/diff.ts

@@ -1,31 +1,20 @@
 // src/core/diff.ts
 import fs from "fs";
 import path from "path";
+import { PatchItem } from "./schema";
 
-export interface DiffPatch {
-  type: "modify" | "create" | "delete";
-  path: string;
-  content?: string;
-}
-
-export function applyDiff(basePath: string, patches: DiffPatch[]) {
+export function applyDiff(basePath: string, patches: PatchItem[]) {
   for (const patch of patches) {
+    if (!patch.path) continue;
     const fullPath = path.join(basePath, patch.path);
 
-    switch (patch.type) {
-      case "delete": {
-        if (fs.existsSync(fullPath)) {
-          fs.unlinkSync(fullPath);
-        }
-        break;
-      }
-
-      case "create":
-      case "modify": {
-        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-        fs.writeFileSync(fullPath, patch.content ?? "", "utf8");
-        break;
+    if (patch.content === null || patch.content === undefined) {
+      if (fs.existsSync(fullPath)) {
+        fs.unlinkSync(fullPath);
       }
+    } else {
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, patch.content, "utf8");
     }
   }
-}
+}