johankit 0.0.2 → 0.0.4

package/src/cli/commands/paste.ts

@@ -1,6 +1,9 @@
 // src/cli/commands/paste.ts
 import { writeFiles } from "../../core/write";
 import { readClipboard } from "../../core/clipboard";
+import cleanCodeBlock from "../../utils/cleanCodeBlock";
+import { applyDiff } from "../../core/diff";
+import { validatePatches } from "../../core/validation";
 
 export async function paste(dir: string) {
     try {
@@ -10,28 +13,25 @@ export async function paste(dir: string) {
             throw new Error("Clipboard empty or inaccessible");
         }
 
-        let files;
+        let parsed;
         try {
-            const cleanContent = content.replace(/^\uFEFF/, "").trim();
-            files = JSON.parse(cleanContent);
+            const { cleaned } = cleanCodeBlock(content);
+            parsed = JSON.parse(cleaned);
         } 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");
+        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);
+        } else {
+            throw new Error("JSON is neither FileSnapshot array nor DiffPatch 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");
@@ -40,4 +40,4 @@ export async function paste(dir: string) {
         }
         process.exit(1);
     }
-}
+}

package/src/cli/commands/prompt.ts

@@ -2,15 +2,50 @@
 import { scanDir } from "../../core/scan";
 import { copyToClipboard } from "../../core/clipboard";
 
-export async function prompt(dir: string, userPrompt: string) {
+interface LLMResponseExample {
+  type: 'FileSnapshot' | 'DiffPatch';
+  example: any;
+}
+
+export async function prompt(dir: string, userPrompt: string, diff = false) {
   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"
@@ -26,19 +61,22 @@ ${JSON.stringify(snapshot, null, 2)}
 YOUR TASK
 Propose changes according to the user request.
 
-Return ONLY a JSON array of patches.
+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)"
+  \"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)}
+
 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)")
+- Return ONLY valid JSON inside the \"\`\`\`\"
+- Always return within a Markdown Code Block.
 
 USER REQUEST
 ${userPrompt}
@@ -47,9 +85,9 @@ ${userPrompt}
   try {
     await copyToClipboard(template.trim());
     process.stdout.write(template.trim());
-    process.stdout.write("\n\n✔ Prompt + Snapshot copied to clipboard\n");
+    process.stdout.write("\n\n✔ Prompt + Snapshot + Example 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

@@ -5,11 +5,10 @@ import { copyToClipboard } from "../../core/clipboard";
 import { validatePatches } from "../../core/validation";
 import { writeFiles } from "../../core/write";
 
-export async function sync(dir: string) {
+export async function sync(dir: string, diff = false) {
   try {
     const snapshotBefore = scanDir(dir);
 
-    // Gera prompt genérico para AI com snapshot atual
     const template = `
 You are an AI software engineer.
 
@@ -33,7 +32,7 @@ ${JSON.stringify(snapshotBefore, null, 2)}
 YOUR TASK
 Propose changes according to the user request.
 
-Return ONLY a JSON array of patches.
+Return ONLY a JSON array of ${diff ? 'DiffPatch' : 'FileSnapshot'}.
 
 PATCH FORMAT (STRICT)
 {
@@ -53,7 +52,6 @@ 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;
@@ -63,8 +61,12 @@ USER REQUEST
       throw new Error("Invalid JSON input");
     }
 
-    const validated = validatePatches(patches);
-    applyDiff(dir, validated);
+    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));

package/src/cli/commands/three.ts

@@ -0,0 +1,117 @@
+import path from "path";
+import { Project, SourceFile, SyntaxKind } from "ts-morph";
+import {
+  FileTree,
+  ClassInfo,
+  FunctionInfo,
+  VariableInfo,
+  ExportInfo,
+  FileKind
+} from "types";
+
+/**
+ * Heurística simples para classificar arquivos
+ */
+function detectFileKind(filePath: string, exportsCount: number): FileKind {
+  if (filePath.includes("/cli/")) return "cli";
+  if (filePath.endsWith("index.ts") || filePath.endsWith("main.ts")) return "entry";
+  if (exportsCount === 0) return "util";
+  if (exportsCount > 3) return "domain";
+  return "unknown";
+}
+
+export async function three(dir: string): Promise<FileTree[]> {
+  const project = new Project({});
+
+  project.addSourceFilesAtPaths([
+    `${dir}/**/*.{ts,tsx,js,jsx}`,
+    `!${dir}/**/node_modules/**/*`,
+    `!${dir}/**/dist/**/*`,
+  ]);
+
+  const tree: FileTree[] = [];
+
+  for (const file of project.getSourceFiles()) {
+    const absolutePath = file.getFilePath();
+    const filePath = path.relative(dir, absolutePath);
+
+    if (filePath.includes("node_modules") || filePath.includes("/dist/")) {
+      continue;
+    }
+
+    /* ---------------- IMPORTS ---------------- */
+    const imports = file
+      .getImportDeclarations()
+      .map(i => i.getModuleSpecifierValue());
+
+    /* ---------------- CLASSES ---------------- */
+    const classes: ClassInfo[] = file.getClasses().map(cls => ({
+      name: cls.getName() || "<anonymous>",
+      methods: cls.getMethods().map(m => ({
+        name: m.getName(),
+        params: m.getParameters().map(p => p.getName()),
+        returnType: safeType(() => m.getReturnType().getText()),
+        scope: "class",
+      }))
+    }));
+
+    /* ---------------- FUNCTIONS ---------------- */
+    const functions: FunctionInfo[] = file.getFunctions().map(fn => ({
+      name: fn.getName() || "<anonymous>",
+      params: fn.getParameters().map(p => p.getName()),
+      returnType: safeType(() => fn.getReturnType().getText()),
+      scope: "global",
+    }));
+
+    /* ---------------- VARIABLES ---------------- */
+    const variables: VariableInfo[] = file.getVariableDeclarations().map(v => ({
+      name: v.getName(),
+      type: safeType(() => v.getType().getText()),
+      scope: v.getParent() instanceof SourceFile ? "global" : "local",
+    }));
+
+    /* ---------------- EXPORTS ---------------- */
+    const exports: ExportInfo[] = [];
+    let mainExport: string | undefined;
+
+    file.getExportedDeclarations().forEach((decls, name) => {
+      decls.forEach(d => {
+        let kind: ExportInfo["kind"] = "unknown";
+
+        if (d.getKind() === SyntaxKind.ClassDeclaration) kind = "class";
+        if (d.getKind() === SyntaxKind.FunctionDeclaration) kind = "function";
+        if (d.getKind() === SyntaxKind.VariableDeclaration) kind = "variable";
+        if (d.getKind() === SyntaxKind.TypeAliasDeclaration) kind = "type";
+
+        exports.push({ name, kind });
+      });
+    });
+
+    if (exports.length === 1) {
+      mainExport = exports[0].name;
+    }
+
+    const kind = detectFileKind(filePath, exports.length);
+
+    tree.push({
+      path: filePath,
+      kind,
+      imports,
+      classes,
+      functions,
+      variables,
+      exports,
+      mainExport,
+    });
+  }
+
+  return tree;
+}
+
+function safeType(fn: () => string): string {
+  try {
+    return fn();
+  } catch {
+    return "unknown";
+  }
+}

package/src/core/scan.ts

@@ -34,7 +34,7 @@ export function scanDir(
       // ignore read errors
     }
   }
-  
+
   function shouldIgnore(name: string): boolean {
     if (ignoreSet.has(name)) return true;
     for (const pattern of ignoreSet) {

package/src/index.ts

@@ -1,61 +1,78 @@
 #!/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";
+import { JohankitService } from "./services/JohankitService";
 
 const [, , command, ...args] = process.argv;
+const service = new JohankitService();
 
 async function main() {
-  switch (command) {
-    case "copy": {
-      const dir = args[0] ?? ".";
-      const exts = args[1]?.split(",");
-      await copy(dir);
-      break;
-    }
+  try {
+    switch (command) {
+      case "copy": {
+        const dir = args[0] ?? ".";
+        await service.copy(dir);
+        break;
+      }
 
-    case "paste": {
-      const dir = args[0] ?? ".";
-      await paste(dir);
-      break;
-    }
+      case "paste": {
+        const dir = args[0] ?? ".";
+        await service.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);
+      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;
       }
-      await prompt(dir, userPrompt);
-      break;
-    }
 
-    case "sync": {
-      const dir = args[0] ?? ".";
-      await sync(dir);
-      break;
-    }
+      case "sync": {
+        const dir = args[0] ?? ".";
+        await service.sync(dir);
+        break;
+      }
+
+      case "three": {
+        const dir = args[0] ?? ".";
+        const output = await service.three(dir);
+        console.log(output);
+        break;
+      }
 
-    default:
-      help();
+      default:
+        showHelp();
+        break;
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("Error:", error.message);
+    } else {
+      console.error("Unexpected error:", error);
+    }
+    process.exit(1);
   }
 }
 
-function help() {
+function showHelp() {
   console.log(`
 Usage:
-  johankit copy <dir> [exts]
+  johankit copy <dir>
   johankit paste <dir>
-  johankit prompt <dir> "<user request>"
+  johankit prompt <dir> "<user request>" [--diff]
   johankit sync <dir>
+  johankit three <dir>
 
 Examples:
-  johankit prompt src "refatorar para async/await"
+  johankit copy src
+  johankit paste src
+  johankit prompt src "refactor to async/await"
   johankit sync src
+  johankit three src
 `);
 }
 
-main();
+main();
+
+export { JohankitService };

package/src/services/JohankitService.ts

@@ -0,0 +1,70 @@
+import createAsciiTree from "../utils/createAsciiTree";
+import { copy } from "../cli/commands/copy";
+import { paste } from "../cli/commands/paste";
+import { prompt } from "../cli/commands/prompt";
+import { three } from "../cli/commands/three";
+import { scanDir } from "../core/scan";
+import { applyDiff, DiffPatch } from "../core/diff";
+import { validatePatches } from "../core/validation";
+import { writeFiles } from "../core/write";
+
+interface JohankitServiceOptions {
+  isolated?: boolean;
+}
+
+export class JohankitService {
+  private isolated: boolean;
+  private internalInput?: any;
+
+  constructor(options: JohankitServiceOptions = {}) {
+    this.isolated = options.isolated ?? false;
+  }
+
+  setInput(input: any) {
+    this.internalInput = input;
+  }
+
+  async copy(dir: string = ".") {
+    return copy(dir);
+  }
+
+  async paste(dir: string = ".") {
+    return paste(dir);
+  }
+
+  async prompt(dir: string, userPrompt: string, diff = false) {
+    if (!userPrompt) {
+      throw new Error("Missing user prompt");
+    }
+    return prompt(dir, userPrompt, diff);
+  }
+
+  async sync(dir: string = ".", diff = false) {
+    const snapshotBefore = scanDir(dir);
+
+    const input = this.isolated ? this.internalInput : undefined;
+
+    if (!this.isolated && input === undefined) {
+      throw new Error("sync() without isolation must be used via CLI (stdin)");
+    }
+
+    if (!input) {
+      throw new Error("No input provided for isolated sync");
+    }
+
+    if (diff) {
+      const validated = validatePatches(input) as DiffPatch[];
+      applyDiff(dir, validated);
+    } else {
+      writeFiles(dir, input, true);
+    }
+
+    const snapshotAfter = scanDir(dir);
+    return { before: snapshotBefore, after: snapshotAfter };
+  }
+
+  async three(dir: string = ".") {
+    const tree = await three(dir);
+    return createAsciiTree(tree);
+  }
+}

package/src/types.ts

@@ -12,3 +12,48 @@ export interface ScanOptions {
 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;
+}

package/src/utils/cleanCodeBlock.ts

@@ -0,0 +1,13 @@
+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 };
+}

package/src/utils/createAsciiTree.ts

@@ -0,0 +1,53 @@
+import { FileTree } from "types";
+
+export default function createAsciiTree(files: FileTree[]): string {
+  let out = "";
+
+  files.forEach((file, i) => {
+    const lastFile = i === files.length - 1;
+    const fPrefix = lastFile ? "└── " : "├── ";
+    const fIndent = lastFile ? "    " : "│   ";
+
+    out += `${fPrefix}📄 ${file.path}  (${file.kind})\n`;
+
+    /* -------- Imports -------- */
+    if (file.imports.length) {
+      out += `${fIndent}├── 📦 Imports [${file.imports.length}]\n`;
+      file.imports.forEach((imp, idx) => {
+        const last = idx === file.imports.length - 1;
+        out += `${fIndent}${last ? "└── " : "├── "}${imp}\n`;
+      });
+    }
+
+    /* -------- Exports -------- */
+    if (file.exports.length) {
+      out += `${fIndent}├── 🔑 Exports\n`;
+      file.exports.forEach((e, idx) => {
+        const last = idx === file.exports.length - 1;
+        const main = e.name === file.mainExport ? " ⭐" : "";
+        out += `${fIndent}${last ? "└── " : "├── "}${e.name} (${e.kind})${main}\n`;
+      });
+    }
+
+    /* -------- Variables -------- */
+    file.variables.forEach(v => {
+      out += `${fIndent}├── 💡 ${v.name}: ${v.type} (${v.scope})\n`;
+    });
+
+    /* -------- Functions -------- */
+    file.functions.forEach(fn => {
+      out += `${fIndent}├── ⚡ ${fn.name}(${fn.params.join(", ")}): ${fn.returnType}\n`;
+    });
+
+    /* -------- Classes -------- */
+    file.classes.forEach(cls => {
+      out += `${fIndent}├── ⚙️ Class ${cls.name}\n`;
+      cls.methods.forEach((m, mi) => {
+        const last = mi === cls.methods.length - 1;
+        out += `${fIndent}│   ${last ? "└── " : "├── "}➡️ ${m.name}(${m.params.join(", ")}): ${m.returnType}\n`;
+      });
+    });
+  });
+
+  return out;
+}

package/tsconfig.json

@@ -3,6 +3,10 @@
     "target": "ES2020",
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
+    "baseUrl": "./src",
+    "paths": {
+      "*": ["*", "core/*"]
+    },
     "outDir": "dist",
     "rootDir": "src",
     "esModuleInterop": true,

package/dist/tests/cli/commands/copy.test.js

@@ -1,47 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const copy_1 = require("../../../cli/commands/copy");
-const scan = __importStar(require("../../../core/scan"));
-const clipboard = __importStar(require("../../../core/clipboard"));
-jest.mock('../../../core/scan');
-jest.mock('../../../core/clipboard');
-describe('copy', () => {
-    it('should copy single file snapshot to clipboard', () => {
-        scan.scanDir.mockReturnValue([{ path: 'file.txt', content: 'hello' }]);
-        (0, copy_1.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
-            .mockReturnValueOnce([{ path: 'file1.txt', content: 'a' }])
-            .mockReturnValueOnce([{ path: 'file2.txt', content: 'b' }]);
-        (0, copy_1.copy)(['file1.txt', 'file2.txt']);
-        expect(clipboard.copyToClipboard).toHaveBeenCalledWith(JSON.stringify([
-            { path: 'file1.txt', content: 'a' },
-            { path: 'file2.txt', content: 'b' }
-        ], null, 2));
-    });
-});