my-cli-tool-himanshu-v1 0.0.1

package/modes/agent/approval.ts

@@ -0,0 +1,136 @@
+import { select, isCancel } from "@clack/prompts";
+import chalk from "chalk";
+import type { ActionTracker } from "./action-tracker.ts";
+import type { ActionLog } from "./types.ts";
+import { composeBeforeAfter, formatPatch } from "./diff-view.ts";
+import { renderTerminalMarkdown } from "../../tui/terminal-md.ts";
+
+interface ReviewGroup {
+  label: string;
+  actionIds: string[];
+  patch: string | null;
+}
+
+function groupPending(pending: ActionLog[]): ReviewGroup[] {
+  const byPath = new Map<string, ActionLog[]>();
+  const shells: ActionLog[] = [];
+
+  for (const a of pending) {
+    if (a.type === "tool_execute") {
+      shells.push(a);
+      continue;
+    }
+    const key = a.path;
+    if (!byPath.has(key)) byPath.set(key, []);
+    byPath.get(key)!.push(a);
+  }
+
+  const groups: ReviewGroup[] = [];
+
+  const pathEntries = [...byPath.entries()].sort(([a], [b]) =>
+    a.localeCompare(b),
+  );
+  for (const [p, acts] of pathEntries) {
+    const sorted = acts.sort(
+      (x, y) => x.timestamp.getTime() - y.timestamp.getTime(),
+    );
+    const ids = sorted.map((x) => x.id);
+
+    if (sorted.every((x) => x.type === "folder_create")) {
+      groups.push({
+        label: `Create folder: ${p}`,
+        actionIds: ids,
+        patch: null,
+      });
+      continue;
+    }
+
+    const { before, after } = composeBeforeAfter(sorted);
+    const patch = formatPatch(p, before, after);
+    const kinds = [...new Set(sorted.map((x) => x.type))].join(", ");
+    groups.push({ label: `${p} (${kinds})`, actionIds: ids, patch });
+  }
+
+  for (const s of shells) {
+    groups.push({
+      label: `Shell: ${s.details.command ?? "(no command)"}`,
+      actionIds: [s.id],
+      patch: null,
+    });
+  }
+
+  return groups;
+}
+
+export async function runApprovalFlow(
+  tracker: ActionTracker,
+): Promise<boolean> {
+  const pending = tracker.getPendingMutation();
+
+  if (pending.length === 0) {
+    console.log(
+      chalk.dim("\nNo staged file, folder, or shell changes to review.\n"),
+    );
+    return false;
+  }
+
+  const choice = await select({
+    message: "Apply staged changes?",
+    options: [
+      { value: "all", label: "Approve and apply all" },
+      { value: "select", label: "Review one by one" },
+      { value: "cancel", label: "Cancel" },
+    ],
+  });
+
+  if (isCancel(choice) || choice === "cancel") {
+    for (const a of pending) tracker.updateStatus(a.id, "rejected", false);
+    return false;
+  }
+
+  if (choice === "all") {
+    for (const a of pending) tracker.updateStatus(a.id, "approved", true);
+    return true;
+  }
+
+  for (const g of groupPending(pending)) {
+    while (true) {
+      const opt = await select({
+        message: chalk.bold(g.label),
+        options: [
+          { value: "accept", label: "Accept" },
+          { value: "diff", label: "Show diff", hint: g.patch ? "" : "N/A" },
+          { value: "reject", label: "Reject" },
+        ],
+      });
+
+      if (isCancel(opt)) {
+        for (const a of pending) tracker.updateStatus(a.id, "rejected", false);
+        return false;
+      }
+
+      if (opt === "diff") {
+        if (g.patch) {
+          console.log(
+            "\n" +
+              renderTerminalMarkdown("```diff\n" + g.patch + "\n```\n") +
+              "\n",
+          );
+        }
+
+        continue;
+      }
+
+      for (const id of g.actionIds) {
+        tracker.updateStatus(
+          id,
+          opt === "accept" ? "approved" : "rejected",
+          opt === "accept",
+        );
+      }
+      break;
+    }
+  }
+
+  return tracker.getActions().some((a) => a.status === "approved");
+}

package/modes/agent/config.ts

@@ -0,0 +1,68 @@
+export type ActionType =
+  | 'file_create'
+  | 'file_modify'
+  | 'file_delete'
+  | 'folder_create'
+  | 'code_analysis'
+  | 'tool_execute';
+
+export type ActionStatus = 'pending' | 'executed' | 'approved' | 'rejected';
+
+export interface ActionLog {
+  id: string;
+  timestamp: Date;
+  type: ActionType;
+  path: string;
+  details: {
+    before?: string;
+    after?: string;
+    toolName?: string;
+    toolResult?: string;
+    error?: string;
+    command?: string;
+  };
+  status: ActionStatus;
+  userApproved?: boolean;
+}
+
+export interface AgentConfig {
+  codebasePath: string;
+  maxFileSizeToRead: number;
+  excludePatterns: string[];
+  tools: {
+    allowShellExecution: boolean;
+    allowFileModification: boolean;
+    allowFileCreation: boolean;
+    allowFolderCreation: boolean;
+  };
+}
+
+export const defaultAgentConfig = (): AgentConfig => ({
+  codebasePath: process.cwd(),
+  maxFileSizeToRead: 1024 * 1024 ,
+  excludePatterns: [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.next',
+    '*.log',
+    '.env*',
+  ],
+  tools: {
+    allowShellExecution: true,
+    allowFileModification: true,
+    allowFileCreation: true,
+    allowFolderCreation: true,
+  },
+});
+
+export function isMutationType(t: ActionType): boolean {
+  return (
+    t === 'file_create' ||
+    t === 'file_modify' ||
+    t === 'file_delete' ||
+    t === 'folder_create' ||
+    t === 'tool_execute'
+  );
+}

package/modes/agent/diff-view.ts

@@ -0,0 +1,21 @@
+import type { ActionLog } from "./types.ts";
+import { createTwoFilesPatch } from "diff";
+
+export function formatPatch(filePath: string, before: string, after: string): string {
+    return createTwoFilesPatch(filePath,filePath, before, after, "", "", { context: 3 });
+}   
+
+
+export function composeBeforeAfter(sorted: ActionLog[]): {
+    before: string;
+    after: string;
+  } {
+    const first = sorted[0]!;
+    const last = sorted[sorted.length - 1]!;
+    if (last.type === "file_delete")
+      return { before: last.details.before ?? "", after: "" };
+    const before =
+      first.type === "file_create" ? "" : (first.details.before ?? "");
+    const after = last.details.after ?? "";
+    return { before, after };
+  }

package/modes/agent/orchestrator.ts

@@ -0,0 +1,66 @@
+import { isCancel } from "@clack/core";
+import chalk from "chalk";
+import { text } from "@clack/prompts";
+import { ToolLoopAgent, stepCountIs } from "ai";
+import { getAgentModel } from "../../ai/ai.config.ts";
+import { renderTerminalMarkdown } from "../../tui/terminal-md.ts";
+import { ActionTracker } from "./action-tracker.ts";
+import { createAgentTools } from "./agent-tools.ts";
+import { defaultAgentConfig } from "./config.ts";
+import { ToolExecutor } from "./tool-executor.ts";
+import { runApprovalFlow } from "./approval.ts";
+
+export async function runAgentMode(): Promise<void> {
+  console.log(chalk.bold("Agent Mode"));
+
+  const goal = await text({
+    message: "What would you like the agent to do?",
+    placeholder: "Concrete task for this codebase...",
+  });
+  if (isCancel(goal) || !goal.trim()) return;
+
+  const config = defaultAgentConfig();
+  const tracker = new ActionTracker();
+  const executor = new ToolExecutor(tracker, config);
+  const tools = createAgentTools(executor);
+  const agent = new ToolLoopAgent({
+    model: getAgentModel(),
+    stopWhen: stepCountIs(20),
+    instructions: [
+      `Workspace root: ${config.codebasePath}`,
+      "All mutations are staged until approval.",
+    ].join("\n"),
+    tools,
+  });
+
+  const result = await agent.generate({
+    prompt: goal.trim(),
+    onStepFinish: ({ toolCalls }) => {
+      for (const tc of toolCalls) {
+        const preview = JSON.stringify(tc.input).slice(0, 160);
+        console.log(
+          chalk.green("  ✓"),
+          chalk.bold(String(tc.toolName)),
+          chalk.dim(preview + (preview.length >= 160 ? "..." : "")),
+        );
+      }
+    },
+  });
+
+  if (result.text?.trim()) console.log(renderTerminalMarkdown(result.text));
+  
+  const ok = await runApprovalFlow(tracker);
+  if (!ok) return executor.clearStaging();
+
+  const { errors } = executor.applyApprovedFromTracker();
+
+  if (errors.length) {
+    console.log(chalk.red("\nSome operations reported errors:\n"));
+    for (const e of errors) console.log(chalk.red(`  • ${e}`));
+  }
+  else{
+   console.log(chalk.green('\n✓ Applied.\n'));
+  }
+
+  executor.clearStaging()
+}