johankit 0.1.5 → 0.4.2

package/src/core/scan.ts

@@ -1,70 +1,73 @@
-// src/core/scan.ts
 import fs from "fs";
 import path from "path";
-import { FileSnapshot, ScanOptions } from "../types";
+import { FileSnapshot, ScanOptions, Config } from "../types";
+import { loadConfig } from "./config";
 
-export function scanDir(
-  basePath: string,
-  options: ScanOptions = {}
-): FileSnapshot[] {
+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}`);
 
-  const exts = options.extensions?.map(e =>
-    e.startsWith(".") ? e : `.${e}`
-  );
+  const config: Config = loadConfig(base);
+  const ignorePatterns = new Set(config.ignore);
 
-  // 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");
+  // Lê .gitignore e adiciona ao Set
+  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
-    }
+      fs.readFileSync(gitignorePath, 'utf8')
+        .split('\n')
+        .forEach(line => {
+          const trimmed = line.trim();
+          if (trimmed && !trimmed.startsWith('#')) {
+            // Normaliza o caminho do gitignore para o padrão do scanner
+            ignorePatterns.add(trimmed.replace(/^\//, '').replace(/\/$/, ''));
+          }
+        });
+    } catch { }
   }
 
-  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;
-  }
+  // PERFORMANCE: Converte o Set em Array UMA VEZ antes de iniciar o loop
+  const finalIgnoreList = Array.from(ignorePatterns);
 
   function loop(currentPath: string) {
     const entries = fs.readdirSync(currentPath, { withFileTypes: true });
 
     for (const entry of entries) {
-      if (shouldIgnore(entry.name)) continue;
+      const isBinary = entry.name.match(/\.(png|jpg|jpeg|gif|pdf|zip|exe|dll|so|db)$/i);
+      if (isBinary) continue;
 
       const fullPath = path.join(currentPath, entry.name);
+      const relPath = path.relative(base, fullPath).replace(/\\/g, '/');
+
+      // PERFORMANCE: O some() agora opera sobre um array fixo, sem Array.from() interno
+      const shouldIgnore = finalIgnoreList.some(p =>
+        relPath === p || relPath.startsWith(p + '/')
+      );
+
+      if (shouldIgnore) continue;
 
       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"),
-        });
+        try {
+          // PERFORMANCE: Pular arquivos muito grandes evita travar o clipboard
+          const stats = fs.statSync(fullPath);
+          if (stats.size > 1024 * 300) continue; // Reduzi para 300KB para ser mais seguro
+
+          result.push({
+            path: relPath,
+            content: fs.readFileSync(fullPath, 'utf8')
+          });
+        } catch (e) {
+          continue;
+        }
       }
     }
   }
 
   loop(base);
   return result;
-}
+}

package/src/core/schema.ts

@@ -1,41 +1,24 @@
 // 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";
-  }
+export interface PatchItem {
+  path?: string;
+  content?: string | null;
+  type?: 'console';
+  command?: 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");
+export function validatePatches(json: any): PatchItem[] {
+  if (!Array.isArray(json)) {
+    throw new Error("Input must be a valid JSON array");
   }
+  // Validação permissiva: ou tem path (arquivo) ou tem type console + command
+  return json.map((item, index) => {
+    const isFile = typeof item.path === 'string';
+    const isCommand = item.type === 'console' && typeof item.command === 'string';
 
-  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 }`);
+    if (!isFile && !isCommand) {
+      throw new Error(`Item at index ${index} is invalid. Must have 'path' or 'type: console'`);
     }
-  }
-
-  // Assume que o array validado está no formato correto de DiffPatch[]
-  return patches as DiffPatch[];
-}
+    return item as PatchItem;
+  });
+}

package/src/core/validation.ts

@@ -1,28 +1,9 @@
 // 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;
-  });
-}
+import { validatePatches as sharedValidate } from "./schema";
+
+/**
+ * @deprecated Use validatePatches from core/schema instead.
+ */
+export function validatePatches(json: any): any[] {
+  return sharedValidate(json);
+}

package/src/core/write.ts

@@ -1,26 +1,20 @@
 // 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");
-  }
+/**
+ * @deprecated Use applyDiff from core/diff for more flexibility (supports deletes and console commands).
+ */
+export function writeFiles(basePath: string, files: any, commit = true) {
+  // if (commit && files.length > 0) {
+  //   ensureGitCommit("johankit: before write");
+  // }
 
   for (const file of files) {
+    if (!file.path) continue;
     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");
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, file.content || "", "utf8");
   }
-}
+}

package/src/index.ts

@@ -1,78 +1,39 @@
 #!/usr/bin/env node
-
-import { JohankitService } from "./services/JohankitService";
-
-const [, , command, ...args] = process.argv;
-const service = new JohankitService();
-
-async function main() {
-  try {
-    switch (command) {
-      case "copy": {
-        const dir = args[0] ?? ".";
-        await service.copy(dir);
-        break;
-      }
-
-      case "paste": {
-        const dir = args[0] ?? ".";
-        await service.paste(dir);
-        break;
-      }
-
-      case "prompt": {
-        const dir = args[0] ?? ".";
-        const diff = args.includes("--diff");
-        const userPrompt = args.filter(a => a !== "--diff").slice(1).join(" ");
-        await service.prompt(dir, userPrompt, diff);
-        break;
-      }
-
-      case "sync": {
-        const dir = args[0] ?? ".";
-        await service.sync(dir);
-        break;
-      }
-
-      case "tree": {
-        const dir = args[0] ?? ".";
-        const output = await service.tree(dir);
-        console.log(output);
-        break;
-      }
-
-      default:
-        showHelp();
-        break;
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error("Error:", error.message);
-    } else {
-      console.error("Unexpected error:", error);
-    }
-    process.exit(1);
-  }
-}
-
-function showHelp() {
-  console.log(`
-Usage:
-  johankit copy <dir>
-  johankit paste <dir>
-  johankit prompt <dir> "<user request>" [--diff]
-  johankit sync <dir>
-  johankit tree <dir>
-
-Examples:
-  johankit copy src
-  johankit paste src
-  johankit prompt src "refactor to async/await"
-  johankit sync src
-  johankit tree src
-`);
-}
-
-main();
-
-export { JohankitService };
+import { Command } from "commander";
+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 program = new Command();
+
+program
+  .name('johankit')
+  .description('Developer-friendly CLI for codebase snapshots and AI vibe-coding')
+  .version('0.0.3');
+
+program
+  .command('copy [dir] [exts]')
+  .action((dir = '.', exts) => copy(dir, exts?.split(',')));
+
+program
+  .command('paste [dir]')
+  .option('--run', 'execute console commands')
+  .option('-y', 'auto accept commands without confirmation')
+  .option('--dry-run', 'list changes without applying them')
+  .option('--diff', 'show diff and ask for confirmation for each file')
+  .action((dir = '.', opts) => paste(dir, !!opts.run, !!opts.dryRun, !!opts.diff));
+
+program
+  .command('prompt [dir] <request...>')
+  .action((dir = '.', request) => prompt(dir, request.join(' ')));
+
+program
+  .command('sync [dir]')
+  .option('--run', 'execute console commands')
+  .option('-y', 'auto accept commands without confirmation')
+  .option('--dry-run', 'list changes without applying them')
+  .option('--diff', 'show diff and ask for confirmation for each file')
+  .action((dir = '.', opts) => sync(dir, !!opts.run, !!opts.dryRun, !!opts.diff));
+
+program.parse();

package/src/types.ts

@@ -1,59 +1,13 @@
 // src/types.ts
 export interface FileSnapshot {
   path: string;
-  content: string;
+  content: string | null;
 }
 
 export interface ScanOptions {
-  extensions?: string[]; // ['.js', '.ts', '.css']
-  // A opção 'ignore' foi movida para o arquivo de configuração e 'loadConfig'
+  extensions?: string[];
 }
 
 export interface Config {
-  ignore: string[]; // Patterns de arquivos/diretórios a ignorar
-}
-
-export type FileKind =
-  | "entry"
-  | "cli"
-  | "domain"
-  | "infra"
-  | "util"
-  | "unknown";
-
-export interface VariableInfo {
-  name: string;
-  type?: string;
-  scope: "global" | "local";
-}
-
-export interface FunctionInfo {
-  name: string;
-  params: string[];
-  returnType?: string;
-  scope: "global" | "class";
-}
-
-export interface ClassInfo {
-  name: string;
-  methods: FunctionInfo[];
-}
-
-export interface ExportInfo {
-  name: string;
-  kind: "function" | "class" | "variable" | "type" | "unknown";
-}
-
-export interface FileTree {
-  path: string;
-  kind: FileKind;
-
-  imports: string[];
-
-  classes: ClassInfo[];
-  functions: FunctionInfo[];
-  variables: VariableInfo[];
-
-  exports: ExportInfo[];
-  mainExport?: string;
-}
+  ignore: string[];
+}

package/src/utils/cleanCodeBlock.ts

@@ -1,13 +1,22 @@
+// src/utils/cleanCodeBlock.ts
 export default function cleanCodeBlock(content: string) {
-    const langMatch = content.match(/^```(\w+)?/);
-    const lang = langMatch ? langMatch[1] : null;
+  // Regex robusta para capturar o primeiro array JSON dentro ou fora de blocos de código markdown
+  const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/;
+  const match = content.match(codeBlockRegex);
 
-    let cleaned = content.replace(/^\uFEFF/, '');
+  let cleaned = match ? match[1] : content;
 
-    cleaned = cleaned.replace(/^```(\w+)?\s*/, '').replace(/```$/, '');
+  // Remove caracteres invisíveis como BOM (Byte Order Mark) e espaços extras
+  cleaned = cleaned.trim().replace(/\uFEFF/g, "");
 
-    cleaned = cleaned.replace(/[\u0000-\u0008\u000B-\u000C\u000E-\u001F\u007F-\u009F]/g, '');
-    cleaned = cleaned.trim();
+  // Se ainda assim parecer que tem texto antes do array, tenta encontrar o início do array
+  if (!cleaned.startsWith("[")) {
+    const arrayStart = cleaned.indexOf("[");
+    const arrayEnd = cleaned.lastIndexOf("]");
+    if (arrayStart !== -1 && arrayEnd !== -1) {
+      cleaned = cleaned.substring(arrayStart, arrayEnd + 1);
+    }
+  }
 
-    return { lang, cleaned };
-}
+  return { cleaned };
+}

package/tsconfig.json

@@ -1,17 +1,25 @@
 {
-  "exclude": ["types.ts"],
   "compilerOptions": {
     "target": "ES2020",
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
-    "baseUrl": "./src",
+    "baseUrl": ".",
     "paths": {
-      "*": ["*", "core/*"]
+      "*": ["src/*", "src/core/core/*", "cli/*"]
     },
     "outDir": "dist",
-    "rootDir": "src",
+    "rootDir": ".",
     "esModuleInterop": true,
     "strict": true,
     "skipLibCheck": true
-  }
-}
+  },
+  "include": [
+    "src/**/*",
+    "src/core/core/**/*",
+    "cli/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/Readme.md

@@ -1,56 +0,0 @@
-# JohanKit CLI
-
-JohanKit é uma ferramenta para copiar, colar e sincronizar snapshots de código de forma inteligente usando AI.
-
-## Comandos
-
-### Copy
-Copia um diretório ou arquivos específicos para o clipboard em formato JSON.
-
-```bash
-johankit copy <dir> [exts]
-```
-
-- `<dir>`: Diretório a copiar (padrão `.`)
-- `[exts]`: Extensões separadas por vírgula (ex: `ts,js`)
-
-### Paste
-Aplica o conteúdo do clipboard em um diretório.
-
-```bash
-johankit paste <dir>
-```
-
-- `<dir>`: Diretório de destino (padrão `.`)
-
-### Prompt
-Gera um prompt com o snapshot atual do diretório para AI, copiando para o clipboard.
-
-```bash
-johankit prompt <dir> "<user request>"
-```
-
-### Sync
-Aplica patches gerados pela AI em um diretório e atualiza o clipboard com o novo snapshot.
-
-```bash
-johankit sync <dir>
-```
-
-## Exemplo de Uso
-
-```bash
-johankit prompt src "refatorar para async/await"
-johankit sync src
-```
-
-## Configuração
-Crie um arquivo `johankit.yaml` na raiz do projeto para customizar os diretórios e arquivos a ignorar.
-
-```yaml
-ignore:
-  - dist
-  - node_modules
-```
-
-Por padrão, os seguintes diretórios já são ignorados: `.git`, `node_modules`, `dist`, `build`, `coverage`, `tmp`, `temp`.

package/dist/cli/commands/copy.js

@@ -1,21 +0,0 @@
-"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(input) {
-    let snapshot = [];
-    const paths = Array.isArray(input) ? input : [input];
-    for (const p of paths) {
-        const scanned = (0, scan_1.scanDir)(p);
-        snapshot.push(...scanned);
-    }
-    const clipboardJSON = JSON.stringify(snapshot, null, 2);
-    try {
-        await (0, clipboard_1.copyToClipboard)(clipboardJSON);
-    }
-    catch (err) {
-        console.warn("Clipboard unavailable:", err);
-    }
-    return clipboardJSON;
-}

package/dist/cli/commands/paste.js

@@ -1,48 +0,0 @@
-"use strict";
-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 write_1 = require("../../core/write");
-const clipboard_1 = require("../../core/clipboard");
-const cleanCodeBlock_1 = __importDefault(require("../../utils/cleanCodeBlock"));
-const diff_1 = require("../../core/diff");
-const validation_1 = require("../../core/validation");
-async function paste(dir) {
-    try {
-        const content = await (0, clipboard_1.readClipboard)();
-        if (!content) {
-            throw new Error("Clipboard empty or inaccessible");
-        }
-        let parsed;
-        try {
-            const { cleaned } = (0, cleanCodeBlock_1.default)(content);
-            parsed = JSON.parse(cleaned);
-        }
-        catch (e) {
-            throw new Error("Clipboard content is not valid JSON");
-        }
-        if (Array.isArray(parsed) && parsed.every(f => f.path && f.content)) {
-            // Caso seja snapshot
-            (0, write_1.writeFiles)(dir, parsed, true);
-        }
-        else if (Array.isArray(parsed) && parsed.every(f => f.type && f.path)) {
-            // Caso seja DiffPatch
-            const validated = (0, validation_1.validatePatches)(parsed);
-            (0, diff_1.applyDiff)(dir, validated);
-        }
-        else {
-            throw new Error("JSON is neither FileSnapshot array nor DiffPatch array");
-        }
-        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);
-    }
-}