my-cli-tool-himanshu-v1 0.0.1

package/modes/agent/tool-executor.ts

@@ -0,0 +1,430 @@
+import fs from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+import type { ActionLog, AgentConfig } from "./types.ts";
+import { ActionTracker } from "./action-tracker.ts";
+
+const TEXT_EXT = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".md",
+  ".mdx",
+  ".css",
+  ".html",
+  ".yml",
+  ".yaml",
+  ".toml",
+  ".txt",
+]);
+
+function isProbablyTextFile(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase();
+  return TEXT_EXT.has(ext) || ext === "";
+}
+
+export class ToolExecutor {
+  private overlay = new Map<string, string>();
+  private deleted = new Set<string>();
+  private readonly norm = (rel: string) =>
+    path.posix.normalize(rel.split(path.sep).join("/")).replace(/^\.\//, "");
+
+  constructor(
+    private readonly tracker: ActionTracker,
+    private readonly config: AgentConfig,
+  ) {}
+
+  private resolveSafe(rel: string): string {
+    const abs = path.resolve(this.config.codebasePath, rel);
+    const root = path.resolve(this.config.codebasePath);
+    const relCheck = path.relative(root, abs);
+    if (relCheck.startsWith("..") || path.isAbsolute(relCheck)) {
+      throw new Error(`Path escapes workspace: ${rel}`);
+    }
+    return abs;
+  }
+
+  private excluded(relPath: string): boolean {
+    const norm = this.norm(relPath);
+    const segments = norm.split("/");
+    const base = segments[segments.length - 1] ?? "";
+
+    for (const pat of this.config.excludePatterns) {
+      if (pat === "*.log" && base.endsWith(".log")) return true;
+      if (pat === ".env*" && base.startsWith(".env")) return true;
+      if (pat.includes("*")) continue;
+      if (segments.includes(pat) || norm === pat || norm.startsWith(`${pat}/`))
+        return true;
+    }
+    return false;
+  }
+
+  private assertNotExcluded(rel: string, op: string): void {
+    if (this.excluded(rel)) {
+      throw new Error(`${op}: path is excluded by policy: ${rel}`);
+    }
+  }
+
+  getEffectiveText(rel: string): string | undefined {
+    const key = this.norm(rel);
+    if (this.deleted.has(key)) return undefined;
+    if (this.overlay.has(key)) return this.overlay.get(key);
+    const abs = this.resolveSafe(rel);
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) return undefined;
+    return fs.readFileSync(abs, "utf8");
+  }
+
+  readFile(rel: string): string {
+    this.assertNotExcluded(rel, "read_file");
+    const abs = this.resolveSafe(rel);
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) {
+      throw new Error(`File not found: ${rel}`);
+    }
+    const st = fs.statSync(abs);
+    if (st.size > this.config.maxFileSizeToRead) {
+      throw new Error(`File too large: ${rel}`);
+    }
+    const text = fs.readFileSync(abs, "utf8");
+    this.tracker.log({
+      type: "code_analysis",
+      path: this.norm(rel),
+      details: { after: text, toolName: "read_file" },
+      status: "executed",
+    });
+    return text;
+  }
+
+  createFile(rel: string, content: string): string {
+    if (!this.config.tools.allowFileCreation)
+      throw new Error("File creation disabled");
+    this.assertNotExcluded(rel, "create_file");
+    const key = this.norm(rel);
+    const abs = this.resolveSafe(rel);
+    if (fs.existsSync(abs) && !this.deleted.has(key)) {
+      throw new Error(`create_file: already exists: ${rel}`);
+    }
+    this.deleted.delete(key);
+    this.overlay.set(key, content);
+    this.tracker.log({
+      type: "file_create",
+      path: key,
+      details: { after: content },
+      status: "pending",
+    });
+    return `Staged new file: ${key}`;
+  }
+
+  modifyFile(rel: string, content: string): string {
+    if (!this.config.tools.allowFileModification)
+      throw new Error("File modification disabled");
+    this.assertNotExcluded(rel, "modify_file");
+    const before = this.getEffectiveText(rel);
+    if (before === undefined)
+      throw new Error(`modify_file: file not found: ${rel}`);
+    const key = this.norm(rel);
+    this.overlay.set(key, content);
+    this.tracker.log({
+      type: "file_modify",
+      path: key,
+      details: { before, after: content },
+      status: "pending",
+    });
+    return `Staged update: ${key}`;
+  }
+
+  deleteFile(rel: string): string {
+    if (!this.config.tools.allowFileModification)
+      throw new Error("File deletion disabled");
+    this.assertNotExcluded(rel, "delete_file");
+    const before = this.getEffectiveText(rel);
+    if (before === undefined)
+      throw new Error(`delete_file: file not found: ${rel}`);
+    const key = this.norm(rel);
+    this.overlay.delete(key);
+    this.deleted.add(key);
+    this.tracker.log({
+      type: "file_delete",
+      path: key,
+      details: { before },
+      status: "pending",
+    });
+    return `Staged delete: ${key}`;
+  }
+
+  createFolder(rel: string): string {
+    if (!this.config.tools.allowFolderCreation)
+      throw new Error("Folder creation disabled");
+    this.assertNotExcluded(rel, "create_folder");
+    const key = this.norm(rel);
+    this.tracker.log({
+      type: "folder_create",
+      path: key,
+      details: { after: key },
+      status: "pending",
+    });
+    return `Staged folder: ${key}`;
+  }
+
+  listFiles(rel: string, recursive: boolean): string {
+    this.assertNotExcluded(rel, "list_files");
+    const abs = this.resolveSafe(rel);
+    if (!fs.existsSync(abs)) throw new Error(`list_files: not found: ${rel}`);
+
+    const lines: string[] = [];
+    const walk = (dir: string, prefix: string) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const ent of entries) {
+        const full = path.join(dir, ent.name);
+        const relP = path.relative(this.config.codebasePath, full);
+        if (this.excluded(relP)) continue;
+        if (ent.isDirectory()) {
+          lines.push(`${prefix}${ent.name}/`);
+          if (recursive) walk(full, `${prefix}${ent.name}/`);
+        } else {
+          lines.push(`${prefix}${ent.name}`);
+        }
+      }
+    };
+
+    if (fs.statSync(abs).isDirectory()) walk(abs, "");
+    else lines.push(path.relative(this.config.codebasePath, abs));
+
+    const out = lines.sort().join("\n");
+    this.tracker.log({
+      type: "code_analysis",
+      path: this.norm(rel),
+      details: { after: out, toolName: "list_files" },
+      status: "executed",
+    });
+    return out || "(empty)";
+  }
+
+  searchFiles(
+    rootRel: string,
+    globPattern: string,
+    contentQuery?: string,
+  ): string {
+    this.assertNotExcluded(rootRel, "search_files");
+    const rootAbs = this.resolveSafe(rootRel);
+    if (!fs.existsSync(rootAbs))
+      throw new Error(`search_files: root not found: ${rootRel}`);
+
+    const results: string[] = [];
+    const regexFromGlob = (g: string): RegExp => {
+      const escaped = g
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, "§§")
+        .replace(/\*/g, "[^/\\\\]*")
+        .replace(/§§/g, ".*")
+        .replace(/\?/g, ".");
+      return new RegExp(`^${escaped}$`, "i");
+    };
+    const nameRe = regexFromGlob(globPattern.replace(/\\/g, "/"));
+
+    const walk = (dir: string) => {
+      for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, ent.name);
+        const relP = path
+          .relative(this.config.codebasePath, full)
+          .split(path.sep)
+          .join("/");
+        if (this.excluded(relP)) continue;
+        if (ent.isDirectory()) walk(full);
+        else if (nameRe.test(relP) || nameRe.test(ent.name)) {
+          if (contentQuery) {
+            if (!isProbablyTextFile(full)) continue;
+            const text = fs.readFileSync(full, "utf8");
+            if (!text.includes(contentQuery)) continue;
+          }
+          results.push(relP);
+        }
+      }
+    };
+
+    if (fs.statSync(rootAbs).isDirectory()) walk(rootAbs);
+    else {
+      const relP = path
+        .relative(this.config.codebasePath, rootAbs)
+        .split(path.sep)
+        .join("/");
+      results.push(relP);
+    }
+
+    const out = [...new Set(results)].sort().join("\n");
+    this.tracker.log({
+      type: "code_analysis",
+      path: this.norm(rootRel),
+      details: { after: out || "(no matches)", toolName: "search_files" },
+      status: "executed",
+    });
+    return out || "(no matches)";
+  }
+
+  analyzeCodebase(rootRel: string): string {
+    const rootAbs = this.resolveSafe(rootRel);
+    if (!fs.existsSync(rootAbs))
+      throw new Error(`analyze_codebase: not found: ${rootRel}`);
+
+    let files = 0;
+    let dirs = 0;
+    const walk = (dir: string) => {
+      for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, ent.name);
+        const relP = path.relative(this.config.codebasePath, full);
+        if (this.excluded(relP)) continue;
+        if (ent.isDirectory()) {
+          dirs++;
+          walk(full);
+        } else {
+          files++;
+        }
+      }
+    };
+    if (fs.statSync(rootAbs).isDirectory()) walk(rootAbs);
+    else files = 1;
+
+    const summary = `Files: ${files} | Directories: ${dirs}`;
+    this.tracker.log({
+      type: "code_analysis",
+      path: this.norm(rootRel),
+      details: { after: summary, toolName: "analyze_codebase" },
+      status: "executed",
+    });
+    return summary;
+  }
+
+  queueShell(command: string): string {
+    if (!this.config.tools.allowShellExecution)
+      throw new Error("Shell execution disabled");
+    this.tracker.log({
+      type: "tool_execute",
+      path: "shell",
+      details: { command, toolName: "execute_shell" },
+      status: "pending",
+    });
+    return `Shell queued: ${command}`;
+  }
+
+  skillRoots(): string[] {
+    const extra =
+      process.env.SKILLS_DIRS?.split(/[;]/)
+        .map((s) => s.trim())
+        .filter(Boolean) ?? [];
+    return [
+      ...extra,
+      path.join(homedir(), ".cursor/skills-cursor"),
+      path.join(homedir(), ".claude/skills"),
+    ];
+  }
+
+  listSkills(): string {
+    const lines: string[] = [];
+    for (const root of this.skillRoots()) {
+      if (!fs.existsSync(root)) continue;
+      const walk = (dir: string) => {
+        for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, ent.name);
+          if (ent.isDirectory()) walk(full);
+          else if (ent.name === "SKILL.md") lines.push(full);
+        }
+      };
+      walk(root);
+    }
+    const out = lines.sort().join("\n");
+    this.tracker.log({
+      type: "code_analysis",
+      path: "skills",
+      details: { after: out || "(none)", toolName: "list_skills" },
+      status: "executed",
+    });
+    return out || "(none)";
+  }
+
+  readSkill(skillPath: string): string {
+    const abs = path.isAbsolute(skillPath)
+      ? path.normalize(skillPath)
+      : path.normalize(path.resolve(this.config.codebasePath, skillPath));
+    const allowed = this.skillRoots().some((root) => {
+      const r = path.resolve(root);
+      return abs === r || abs.startsWith(r + path.sep);
+    });
+    if (!allowed) throw new Error("read_skill: outside skill roots");
+    const text = fs.readFileSync(abs, "utf8");
+    this.tracker.log({
+      type: "code_analysis",
+      path: abs,
+      details: { after: text, toolName: "read_skill" },
+      status: "executed",
+    });
+    return text;
+  }
+
+  applyApprovedFromTracker(): { errors: string[] } {
+    const errors: string[] = [];
+    const all = [...this.tracker.getActions()];
+
+    for (const a of all.filter(
+      (x) => x.type === "folder_create" && x.status === "approved",
+    )) {
+      try {
+        fs.mkdirSync(this.resolveSafe(a.path), { recursive: true });
+      } catch (e) {
+        errors.push(String(e));
+      }
+    }
+
+    const fileOps = all
+      .filter(
+        (a) =>
+          (a.type === "file_create" ||
+            a.type === "file_modify" ||
+            a.type === "file_delete") &&
+          a.status === "approved",
+      )
+      .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+
+    const lastByPath = new Map<string, ActionLog>();
+    for (const a of fileOps) lastByPath.set(this.norm(a.path), a);
+
+    for (const [p, a] of lastByPath) {
+      try {
+        if (a.type === "file_delete")
+          fs.rmSync(this.resolveSafe(p), { force: true });
+        else {
+          const target = this.resolveSafe(p);
+          fs.mkdirSync(path.dirname(target), { recursive: true });
+          fs.writeFileSync(target, a.details.after ?? "", "utf8");
+        }
+      } catch (e) {
+        errors.push(String(e));
+      }
+    }
+
+    for (const a of all.filter(
+      (x) => x.type === "tool_execute" && x.status === "approved",
+    )) {
+      const cmd = a.details.command;
+      if (!cmd) continue;
+      const r = spawnSync(cmd, {
+        shell: true,
+        cwd: this.config.codebasePath,
+        encoding: "utf8",
+        maxBuffer: 16 * 1024 * 1024,
+      });
+      if (r.status && r.status !== 0)
+        errors.push(`shell exit ${r.status}: ${cmd}`);
+    }
+
+    return { errors };
+  }
+
+  clearStaging(): void {
+    this.overlay.clear();
+    this.deleted.clear();
+  }
+}

package/modes/agent/types.ts

@@ -0,0 +1,55 @@
+export type ActionType =
+  | "code_analysis"
+  | "file_create"
+  | "file_modify"
+  | "file_delete"
+  | "folder_create"
+  | "tool_execute";
+
+export type ActionStatus = "pending" | "approved" | "rejected" | "executed";
+
+export interface ActionDetails {
+  before?: string;
+  after?: string;
+  command?: string;
+  toolName?: string;
+}
+
+export interface ActionLog {
+  id: string;
+  timestamp: Date;
+  type: ActionType;
+  path: string;
+  details: ActionDetails;
+  status: ActionStatus;
+  userApproved?: boolean;
+}
+
+export interface AgentToolsConfig {
+  allowFileCreation: boolean;
+  allowFileModification: boolean;
+  allowFolderCreation: boolean;
+  allowShellExecution: boolean;
+}
+
+export interface AgentConfig {
+  codebasePath: string;
+  excludePatterns: string[];
+  maxFileSizeToRead: number;
+  tools: AgentToolsConfig;
+}
+
+export type ActionLogInput = Omit<ActionLog, "id" | "timestamp"> &
+  Partial<Pick<ActionLog, "id" | "timestamp">>;
+
+const MUTATION_TYPES = new Set<ActionType>([
+  "file_create",
+  "file_modify",
+  "file_delete",
+  "folder_create",
+  "tool_execute",
+]);
+
+export function isMutationType(type: ActionType): boolean {
+  return MUTATION_TYPES.has(type);
+}

package/modes/cli.ts

@@ -0,0 +1,25 @@
+import { isCancel, select } from "@clack/prompts";
+import chalk from "chalk";
+import { runAgentMode } from "./agent/orchestrator.ts";
+
+export async function runCliMode(): Promise<void> {
+  const mode = await select({
+    message: "Choose CLI sub-mode",
+    options: [
+      { value: "agent", label: "Agent Mode" },
+      { value: "plan", label: "Plan Mode" },
+      { value: "ask", label: "Ask Mode" },
+      { value: "back", label: "<- Back to main menu" },
+    ],
+  });
+  if (isCancel(mode) || mode === "back") return;
+
+  if (mode === "agent") {
+    await runAgentMode();
+    return;
+  }
+
+  if (mode === "plan" || mode === "ask") {
+    console.log(chalk.yellow("Mode is not implemented yet..."));
+  }
+}

package/modes/plan/orchestrator.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import chalk from "chalk";
+import { confirm, isCancel, text } from "@clack/prompts";
+import { ToolLoopAgent, stepCountIs, tool } from "ai";
+import { getAgentModel } from "../../ai/ai.config.ts";
+import { ActionTracker } from "../agent/action-tracker.ts";
+import { ToolExecutor } from "../agent/tool-executor.ts";
+import { createAgentTools } from "../agent/agent-tools.ts";
+import { defaultAgentConfig } from "../agent/config.ts";
+import { runApprovalFlow } from "../agent/approval.ts";
+import { renderTerminalMarkdown } from "../../tui/terminal-md.ts";
+
+
+export function createAskTools(executor: ToolExecutor) {
+    return {
+        read_file: tool({
+            description: "Read a file in the codebase",
+            inputSchema: z.object({
+                path: z.string(),
+            }),
+            execute: async ({ path }) => executor.readFile(path),
+        }),
+        search_files: tool({
+            description: "Search for files in the codebase",
+            inputSchema: z.object({
+                root: z.string().default("."),
+                glob: z.string().default("**/*"),
+                query: z.string().optional(),
+            }),
+            execute: async ({ root, glob, query }) =>
+                executor.searchFiles(root, glob, query),
+        }),
+        list_skills: tool({
+            description: "List all available agent skills",
+            inputSchema: z.object({}),
+            execute: async () => executor.listSkills(),
+        }),
+        read_skill: tool({
+            description: "Read a skill file by path",
+            inputSchema: z.object({
+                path: z.string(),
+            }),
+            execute: async ({ path }) => executor.readSkill(path),
+        }),
+    }
+}
+
+export async function runAskMode(){
+    console.log(chalk.bold("\n 💬 Ask Mode \n")); 
+    const questions = await text({ message: "What do you want to ask?" })    
+    const config = defaultAgentConfig()
+    config.tools.allowFileCreation = true
+    config.tools.allowFileModification = false;
+    config.tools.allowFolderCreation = false;
+    config.tools.allowShellExecution = false;
+
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "my-cli-tool-himanshu-v1",
+  "version": "0.0.1",
+  "main": "index.ts",
+  "bin": {
+    "my-cli-tool-himanshu-v1": "./index.ts"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@clack/core": "^1.3.0",
+    "@clack/prompts": "^1.3.0",
+    "@mendable/firecrawl-js": "^4.23.0",
+    "@openrouter/ai-sdk-provider": "^2.9.0",
+    "@types/marked-terminal": "^6.1.1",
+    "ai": "^6.0.180",
+    "chalk": "^5.6.2", 
+    "commander": "^14.0.3",
+    "diff": "^9.0.0",
+    "figlet": "^1.11.0",
+    "marked": "^18.0.3",
+    "marked-terminal": "^7.3.0",
+    "telegraf": "^4.16.3",
+    "zod": "^4.1.12"
+  },
+  "private": false,
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/figlet": "^1.7.0",
+    "@types/node": "^25.9.2",
+    "typescript": "^6.0.3"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "types": ["bun"],
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/tui/terminal-md.ts

@@ -0,0 +1,20 @@
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+
+let ready = false;
+
+function ensureMarked(): void {
+  if (ready) return;
+  const w = Math.max(40, Math.min(process.stdout.columns || 80, 120));
+  marked.use(
+    markedTerminal({ width: w, reflowText: true }, {}) as Parameters<
+      typeof marked.use
+    >[0],
+  );
+  ready = true;
+}
+
+export function renderTerminalMarkdown(source: string): string {
+  ensureMarked();
+  return marked.parse(source.trimEnd(), { async: false }) as string;
+}

package/tui/wakeup.ts

@@ -0,0 +1,53 @@
+import { select, isCancel } from "@clack/prompts";
+import chalk from "chalk";
+import figlet from "figlet";
+import { runCliMode } from "../modes/cli.ts";
+
+const BANNER_FONT = "ANSI Shadow";
+const SHADOW = chalk.hex("#5b4e9d");
+const FACE = chalk.hex("e8dcf8").bold;
+
+function printBannerWithShadow(ascii: string): void {
+  const bannerLines = ascii.replace(/\s+$/, "").split("\n");
+  const maxLen = Math.max(...bannerLines.map((l) => l.length), 0);
+  const rowWidth = maxLen + 2;
+
+  for (const line of bannerLines) {
+    console.log(SHADOW(("  " + line).padEnd(rowWidth)));
+  }
+  process.stdout.write(`\x1b[${bannerLines.length}A`);
+  for (const line of bannerLines) {
+    console.log(FACE(line.padEnd(rowWidth)));
+  }
+  console.log();
+}
+
+export async function runWakeup(): Promise<void> {
+  let ascii: string;
+  try {
+    ascii = figlet.textSync("My CLI Tool", { font: BANNER_FONT });
+  } catch {
+    ascii = figlet.textSync("My CLI Tool", { font: "Standard" });
+  }
+  printBannerWithShadow(ascii);
+
+  const mode = await select({
+    message: "Which mode do you want to proceed with?",
+    options: [
+      { value: "cli", label: "CLI" },
+      { value: "telegram", label: "Telegram" },
+      { value: "exit", label: "Exit" },
+    ],
+  });
+  if (isCancel(mode)) {
+    process.exit(0);
+  }
+  if (mode === "cli") {
+    console.log(chalk.dim("CLI command running..."));
+    await runCliMode();
+  } else if (mode === "exit") {
+    console.log(chalk.dim("Exit command running..."));
+  } else {
+    console.log(chalk.dim("Telegram command running..."));
+  }
+}