johankit 0.0.2

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "johankit",
+  "version": "0.0.2",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "johankit": "./dist/index.js"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "tsc",
+    "start": "ts-node src/index.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/jest": "^29.5.3",
+    "@types/node": "^25.0.1",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "clipboardy": "^5.0.2",
+    "commander": "^14.0.2"
+  }
+}

package/src/cli/commands/copy.ts

@@ -0,0 +1,22 @@
+import { scanDir } from "../../core/scan";
+import { copyToClipboard } from "../../core/clipboard";
+
+export function copy(input: string | string[]) {
+  let snapshot;
+
+  if (Array.isArray(input)) {
+    snapshot = input.map(path => {
+      const fileSnapshot = scanDir(path);
+      if (fileSnapshot.length !== 1) {
+        throw new Error(`Expected single file for path: ${path}`);
+      }
+      return fileSnapshot[0];
+    });
+  } else {
+    const stat = scanDir(input);
+    snapshot = stat.length === 1 ? stat : scanDir(input);
+  }
+
+  const clipboardJSON = JSON.stringify(snapshot, null, 2); // <- garante JSON válido
+  copyToClipboard(clipboardJSON);
+}

package/src/cli/commands/paste.ts

@@ -0,0 +1,43 @@
+// src/cli/commands/paste.ts
+import { writeFiles } from "../../core/write";
+import { readClipboard } from "../../core/clipboard";
+
+export async function paste(dir: string) {
+    try {
+        const content = await 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}");
+        }
+
+        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);
+    }
+}

package/src/cli/commands/prompt.ts

@@ -0,0 +1,55 @@
+// src/cli/commands/prompt.ts
+import { scanDir } from "../../core/scan";
+import { copyToClipboard } from "../../core/clipboard";
+
+export async function prompt(dir: string, userPrompt: string) {
+  const snapshot = 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 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");
+  }
+}

package/src/cli/commands/sync.ts

@@ -0,0 +1,88 @@
+// src/cli/commands/sync.ts
+import { scanDir } from "../../core/scan";
+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) {
+  try {
+    const snapshotBefore = 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 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 = validatePatches(patches);
+    applyDiff(dir, validated);
+
+    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.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

@@ -0,0 +1,56 @@
+// src/core/clipboard.ts
+import { spawn } from "child_process";
+
+export function copyToClipboard(text: string): Promise<void> {
+  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 = spawn(command, args, { stdio: ["pipe", "ignore", "ignore"] });
+
+    child.on("error", (err) => reject(err));
+    child.on("close", () => resolve());
+
+    child.stdin.write(text);
+    child.stdin.end();
+  });
+}
+
+export function readClipboard(): Promise<string> {
+  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 = 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/, ""));
+      }
+    });
+  });
+}

package/src/core/config.ts

@@ -0,0 +1,50 @@
+// src/core/config.ts
+import path from "path";
+import { readFileSync } from "fs";
+import { load } from "js-yaml";
+import { Config } from "../types";
+
+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.
+ */
+export function loadConfig(basePath: string): Config {
+  const configPath = path.join(basePath, CONFIG_FILENAME);
+
+  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,
+      };
+    }
+
+    console.warn(`[johankit] Aviso: Falha ao carregar ${CONFIG_FILENAME}. Usando defaults.`, error);
+    return {
+      ignore: DEFAULT_IGNORE,
+    };
+  }
+}

package/src/core/diff.ts

@@ -0,0 +1,31 @@
+// src/core/diff.ts
+import fs from "fs";
+import path from "path";
+
+export interface DiffPatch {
+  type: "modify" | "create" | "delete";
+  path: string;
+  content?: string;
+}
+
+export function applyDiff(basePath: string, patches: DiffPatch[]) {
+  for (const patch of patches) {
+    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;
+      }
+    }
+  }
+}

package/src/core/git.ts

@@ -0,0 +1,39 @@
+// src/core/git.ts
+import { execSync } from "child_process";
+import crypto from "crypto";
+
+function getDiffHash() {
+  try {
+    const diff = execSync("git diff --staged", { encoding: "utf8" });
+    if (!diff.trim()) return null;
+
+    return crypto
+      .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}`;
+}
+
+export function ensureGitCommit(message?: string) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+    execSync("git add .");
+
+    const commitMessage = message ?? defaultCommitMessage();
+    execSync(`git commit -m "${commitMessage}"`, { stdio: "ignore" });
+  } catch {
+    // noop: no git or nothing to commit
+  }
+}

package/src/core/scan.ts

@@ -0,0 +1,70 @@
+// src/core/scan.ts
+import fs from "fs";
+import path from "path";
+import { FileSnapshot, ScanOptions } from "../types";
+
+export function scanDir(
+  basePath: string,
+  options: ScanOptions = {}
+): FileSnapshot[] {
+  const result: FileSnapshot[] = [];
+  const base = path.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.join(base, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    try {
+      const lines = fs.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: string): boolean {
+    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: string) {
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (shouldIgnore(entry.name)) continue;
+
+      const fullPath = path.join(currentPath, entry.name);
+
+      if (entry.isDirectory()) {
+        loop(fullPath);
+      } else {
+        if (exts && !exts.includes(path.extname(entry.name))) continue;
+
+        result.push({
+          path: path.relative(base, fullPath).replace(/\\/g, "/"),
+          content: fs.readFileSync(fullPath, "utf8"),
+        });
+      }
+    }
+  }
+
+  loop(base);
+  return result;
+}

package/src/core/schema.ts

@@ -0,0 +1,41 @@
+// src/core/schema.ts
+import { DiffPatch } from "./diff";
+
+/**
+ * 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: any): boolean {
+  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.
+ */
+export function validatePatches(patches: any): DiffPatch[] {
+  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 as DiffPatch[];
+}

package/src/core/validation.ts

@@ -0,0 +1,28 @@
+// src/core/validation.ts
+import { DiffPatch } from "./diff";
+
+export function validatePatches(json: any): DiffPatch[] {
+  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 as DiffPatch;
+  });
+}

package/src/core/write.ts

@@ -0,0 +1,26 @@
+// src/core/write.ts
+import fs from "fs";
+import path from "path";
+import { FileSnapshot } from "../types";
+import { ensureGitCommit } from "./git";
+
+export function writeFiles(
+  basePath: string,
+  files: FileSnapshot[],
+  commit = true
+) {
+  if (commit) {
+    ensureGitCommit("johankit: before paste");
+  }
+
+  for (const file of files) {
+    const fullPath = path.join(basePath, file.path);
+    const dir = path.dirname(fullPath);
+
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(fullPath, file.content, "utf8");
+  }
+}

package/src/index.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { copy } from "./cli/commands/copy";
+import { paste } from "./cli/commands/paste";
+import { prompt } from "./cli/commands/prompt";
+import { sync } from "./cli/commands/sync";
+
+const [, , command, ...args] = process.argv;
+
+async function main() {
+  switch (command) {
+    case "copy": {
+      const dir = args[0] ?? ".";
+      const exts = args[1]?.split(",");
+      await copy(dir);
+      break;
+    }
+
+    case "paste": {
+      const dir = args[0] ?? ".";
+      await paste(dir);
+      break;
+    }
+
+    case "prompt": {
+      const dir = args[0] ?? ".";
+      const userPrompt = args.slice(1).join(" ");
+      if (!userPrompt) {
+        console.error("Missing user prompt");
+        process.exit(1);
+      }
+      await prompt(dir, userPrompt);
+      break;
+    }
+
+    case "sync": {
+      const dir = args[0] ?? ".";
+      await sync(dir);
+      break;
+    }
+
+    default:
+      help();
+  }
+}
+
+function help() {
+  console.log(`
+Usage:
+  johankit copy <dir> [exts]
+  johankit paste <dir>
+  johankit prompt <dir> "<user request>"
+  johankit sync <dir>
+
+Examples:
+  johankit prompt src "refatorar para async/await"
+  johankit sync src
+`);
+}
+
+main();

package/src/tests/cli/commands/copy.test.ts

@@ -0,0 +1,26 @@
+import { copy } from '../../../cli/commands/copy';
+import * as scan from '../../../core/scan';
+import * as clipboard from '../../../core/clipboard';
+
+jest.mock('../../../core/scan');
+jest.mock('../../../core/clipboard');
+
+describe('copy', () => {
+  it('should copy single file snapshot to clipboard', () => {
+    (scan.scanDir as jest.Mock).mockReturnValue([{ path: 'file.txt', content: 'hello' }]);
+    copy('file.txt');
+    expect(clipboard.copyToClipboard).toHaveBeenCalledWith(JSON.stringify([{ path: 'file.txt', content: 'hello' }], null, 2));
+  });
+
+  it('should copy multiple file snapshots to clipboard', () => {
+    (scan.scanDir as jest.Mock)
+      .mockReturnValueOnce([{ path: 'file1.txt', content: 'a' }])
+      .mockReturnValueOnce([{ path: 'file2.txt', content: 'b' }]);
+
+    copy(['file1.txt', 'file2.txt']);
+    expect(clipboard.copyToClipboard).toHaveBeenCalledWith(JSON.stringify([
+      { path: 'file1.txt', content: 'a' },
+      { path: 'file2.txt', content: 'b' }
+    ], null, 2));
+  });
+});