johankit 0.1.5 → 1.0.0

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,28 @@ 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);
+  // Lista de possíveis nomes para o arquivo de configuração
+  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; // Para no primeiro que encontrar
+      } 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,
-    };
   }
-}
+
+  // Set para garantir que não existam duplicatas nos padrões de 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");
     }
   }
-}
+}

package/src/core/scan.ts

@@ -1,70 +1,79 @@
-// 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[] {
+// Cache para evitar re-leitura de configurações durante o mesmo processo
+let cachedConfig: Config | null = null;
+let cachedIgnoreList: string[] | null = null;
+
+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}`
-  );
-
-  // Default ignores
-  const ignoreSet = new Set([
-    "node_modules", ".git", "dist", "build", ".DS_Store", "coverage", ".env", "yarn.lock",
-  ]);
+  if (!cachedConfig) {
+    cachedConfig = loadConfig(base);
+    const ignorePatterns = new Set(cachedConfig.ignore);
 
-  // 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
+    const gitignorePath = path.join(base, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      try {
+        fs.readFileSync(gitignorePath, 'utf8')
+          .split('\n')
+          .forEach(line => {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+              ignorePatterns.add(trimmed.replace(/^\//, '').replace(/\/$/, ''));
+            }
+          });
+      } catch { }
     }
+    cachedIgnoreList = Array.from(ignorePatterns);
   }
 
-  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;
-  }
+  const finalIgnoreList = cachedIgnoreList!;
 
   function loop(currentPath: string) {
     const entries = fs.readdirSync(currentPath, { withFileTypes: true });
 
     for (const entry of entries) {
-      if (shouldIgnore(entry.name)) continue;
+      const name = entry.name;
+      
+      // Otimização: Verificação rápida de binários e pastas ocultas comuns
+      if (name.startsWith('.') && name !== '.gitignore') continue;
+      if (name.match(/\.(png|jpg|jpeg|gif|pdf|zip|exe|dll|so|db|map|lock)$/i)) continue;
+
+      const fullPath = path.join(currentPath, name);
+      const relPath = path.relative(base, fullPath).replace(/\\/g, '/');
+
+      const shouldIgnore = finalIgnoreList.some(p => 
+        relPath === p || relPath.startsWith(p + '/')
+      );
 
-      const fullPath = path.join(currentPath, entry.name);
+      if (shouldIgnore) continue;
 
       if (entry.isDirectory()) {
         loop(fullPath);
       } else {
-        if (exts && !exts.includes(path.extname(entry.name))) continue;
+        if (exts && !exts.includes(path.extname(name))) continue;
 
-        result.push({
-          path: path.relative(base, fullPath).replace(/\\/g, "/"),
-          content: fs.readFileSync(fullPath, "utf8"),
-        });
+        try {
+          const stats = fs.statSync(fullPath);
+          // Ignora arquivos maiores que 200KB para manter performance do clipboard
+          if (stats.size > 200 * 1024) continue;
+
+          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,44 @@
 #!/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')
+  .option('--watch', 'continuously watch clipboard for new patches')
+  .option('--auto', 'alias for --watch with auto-accept')
+  .action((dir = '.', opts) => {
+    const isAuto = !!opts.auto;
+    sync(dir, isAuto || !!opts.run, !!opts.dryRun, !!opts.diff, isAuto || !!opts.watch);
+  });
+
+program.parse();

package/src/tests/cleanCodeBlock.test.ts

@@ -0,0 +1,21 @@
+import cleanCodeBlock from '../utils/cleanCodeBlock';
+
+describe('cleanCodeBlock', () => {
+  it('should extract JSON from markdown blocks', () => {
+    const input = 'Check this: ```json [{"path": "test"}] ``` and some text';
+    const { cleaned } = cleanCodeBlock(input);
+    expect(cleaned).toBe('[{"path": "test"}]');
+  });
+
+  it('should handle raw JSON arrays', () => {
+    const input = '[{"path": "test"}]';
+    const { cleaned } = cleanCodeBlock(input);
+    expect(cleaned).toBe('[{"path": "test"}]');
+  });
+
+  it('should remove invisible characters', () => {
+    const input = '\uFEFF[{"path": "test"}]';
+    const { cleaned } = cleanCodeBlock(input);
+    expect(cleaned).toBe('[{"path": "test"}]');
+  });
+});

package/src/tests/scan.test.ts

@@ -0,0 +1,33 @@
+import { scanDir } from '../core/scan';
+import fs from 'fs';
+import path from 'path';
+
+describe('scanDir', () => {
+  const testDir = path.join(__dirname, 'test-tmp');
+
+  beforeEach(() => {
+    if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true });
+    fs.mkdirSync(testDir);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true });
+  });
+
+  it('should scan files in a directory', () => {
+    fs.writeFileSync(path.join(testDir, 'test.ts'), 'console.log("hello")');
+    const results = scanDir(testDir);
+    expect(results.length).toBe(1);
+    expect(results[0].path).toBe('test.ts');
+    expect(results[0].content).toBe('console.log("hello")');
+  });
+
+  it('should respect ignore patterns from config', () => {
+    fs.mkdirSync(path.join(testDir, 'node_modules'));
+    fs.writeFileSync(path.join(testDir, 'node_modules/ignore.ts'), 'ignore');
+    fs.writeFileSync(path.join(testDir, 'keep.ts'), 'keep');
+    const results = scanDir(testDir);
+    expect(results.find(r => r.path.includes('node_modules'))).toBeUndefined();
+    expect(results.find(r => r.path === 'keep.ts')).toBeDefined();
+  });
+});

package/src/tests/schema.test.ts

@@ -0,0 +1,24 @@
+import { validatePatches } from '../core/schema';
+
+describe('validatePatches', () => {
+  it('should validate correct file patches', () => {
+    const input = [{ path: 'src/index.ts', content: 'test' }];
+    const output = validatePatches(input);
+    expect(output).toEqual(input);
+  });
+
+  it('should validate correct console patches', () => {
+    const input = [{ type: 'console', command: 'npm install' }];
+    const output = validatePatches(input);
+    expect(output).toEqual(input);
+  });
+
+  it('should throw error for invalid items', () => {
+    const input = [{ invalid: 'item' }];
+    expect(() => validatePatches(input)).toThrow();
+  });
+
+  it('should throw error if input is not an array', () => {
+    expect(() => validatePatches({})).toThrow();
+  });
+});

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,13 @@
+// src/utils/cleanCodeBlock.ts
 export default function cleanCodeBlock(content: string) {
-    const langMatch = content.match(/^```(\w+)?/);
-    const lang = langMatch ? langMatch[1] : null;
-
-    let cleaned = content.replace(/^\uFEFF/, '');
-
-    cleaned = cleaned.replace(/^```(\w+)?\s*/, '').replace(/```$/, '');
-
-    cleaned = cleaned.replace(/[\u0000-\u0008\u000B-\u000C\u000E-\u001F\u007F-\u009F]/g, '');
-    cleaned = cleaned.trim();
-
-    return { lang, cleaned };
-}
+  // Regex robusta para capturar o primeiro array JSON ou bloco de código em string suja
+  const jsonRegex = /```json\s*([\s\S]*?)\s*```|(\[\s*{[\s\S]*}\s*\])/;
+  const match = content.match(jsonRegex);
+  
+  let cleaned = match ? (match[1] || match[2]) : content;
+
+  cleaned = cleaned.replace(/^\uFEFF/, '');
+  cleaned = cleaned.replace(/[\u0000-\u0008\u000B-\u000C\u000E-\u001F\u007F-\u009F]/g, '');
+  
+  return { cleaned: cleaned.trim() };
+}