johankit 0.0.3 → 0.0.4

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/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/cli/commands/paste.js

@@ -1,42 +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 = void 0;
-const write_1 = require("../../core/write");
-const clipboard_1 = require("../../core/clipboard");
-const cleanCodeBlock_1 = __importDefault(require("../../utils/cleanCodeBlock"));
-async function paste(dir) {
-    try {
-        const content = await (0, clipboard_1.readClipboard)();
-        if (!content) {
-            throw new Error("Clipboard empty or inaccessible");
-        }
-        let files;
-        try {
-            const { lang, cleaned } = (0, cleanCodeBlock_1.default)(content);
-            files = 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");
-        }
-        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}");
-        }
-        (0, write_1.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);
-    }
-}
-exports.paste = paste;

package/cli/commands/paste.ts

@@ -1,42 +0,0 @@
-import { writeFiles } from "../../core/write";
-import { readClipboard } from "../../core/clipboard";
-import cleanCodeBlock from "../../utils/cleanCodeBlock";
-
-export async function paste(dir: string) {
-    try {
-        const content = await readClipboard();
-
-        if (!content) {
-            throw new Error("Clipboard empty or inaccessible");
-        }
-
-        let files;
-        try {
-            const { lang, cleaned } = cleanCodeBlock(content);
-            files = 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");
-        }
-
-        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/cli/commands/prompt.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prompt = void 0;
-// src/cli/commands/prompt.ts
-const scan_1 = require("../../core/scan");
-const clipboard_1 = require("../../core/clipboard");
-const vm_1 = require("../../core/vm");
-async function prompt(dir, userPrompt) {
-    const snapshot = (0, scan_1.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 {
-        (0, vm_1.runInVm)(`module.exports = async function() { return ${JSON.stringify(template.trim())}; }`)();
-        await (0, clipboard_1.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 execute in VM or copy to clipboard\n");
-    }
-}
-exports.prompt = prompt;

package/cli/commands/prompt.ts

@@ -1,57 +0,0 @@
-// src/cli/commands/prompt.ts
-import { scanDir } from "../../core/scan";
-import { copyToClipboard } from "../../core/clipboard";
-import { runInVm } from "../../core/vm";
-
-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 {
-    runInVm(`module.exports = async function() { return ${JSON.stringify(template.trim())}; }`)();
-    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 execute in VM or copy to clipboard\n");
-  }
-}