@pikaa-ai/pikaa 0.3.5 → 0.3.7

package/dist/cli.js

@@ -975,6 +975,7 @@ async function runTurn(session, turnContext, input) {
             signal,
             execPolicy: session.execPolicy,
             mode: session.collaborationMode,
+            permissionMode: session.permissionMode,
             onPlanUpdate: (plan, explanation) => {
               session.emitEvent({
                 type: "PlanUpdated",
@@ -1125,9 +1126,17 @@ async function submissionLoop(session, queue) {
 // src/security/exec-policy.ts
 class ExecPolicy {
   rules = [];
-  constructor() {
+  mode = "auto";
+  constructor(initialMode = "auto") {
+    this.mode = initialMode;
     this.initDefaultRules();
   }
+  getMode() {
+    return this.mode;
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
   initDefaultRules() {
     this.addRule(/^(git\s+(status|log|diff|branch|show|rev-parse))/i, "allow", "Safe git query");
     this.addRule(/^(ls|dir|cat|type|grep|rg|find|pwd|echo|head|tail|wc|which|where)\b/i, "allow", "Safe read-only shell command");
@@ -1139,8 +1148,47 @@ class ExecPolicy {
   addRule(pattern, decision, description) {
     this.rules.unshift({ pattern, decision, description });
   }
+  shouldPromptFileEdit(filePath) {
+    if (this.mode === "plan") {
+      return {
+        prompt: false,
+        isPlanBlocked: true,
+        reason: "Plan Mode is active. Mutating files is not allowed while planning."
+      };
+    }
+    if (this.mode === "manual") {
+      return {
+        prompt: true,
+        reason: `Manual mode requires approval to modify '${filePath || "file"}'`
+      };
+    }
+    return { prompt: false };
+  }
   evaluate(command) {
     const trimmed = command.trim();
+    if (this.mode === "plan") {
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|which|where)\b/i.test(trimmed);
+      if (isReadOnly) {
+        return { decision: "allow", reason: "Read-only inspection allowed in Plan mode" };
+      }
+      return { decision: "deny", reason: "Cannot execute mutating shell commands in Plan mode" };
+    }
+    if (this.mode === "manual") {
+      return {
+        decision: "prompt",
+        reason: "Manual mode requires confirmation for all shell commands"
+      };
+    }
+    if (this.mode === "accept-edits") {
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|bun\s+test|npm\s+test)\b/i.test(trimmed);
+      if (isReadOnly) {
+        return { decision: "allow", reason: "Safe read-only command in accept-edits mode" };
+      }
+      return {
+        decision: "prompt",
+        reason: "Accept-edits mode requires approval for active shell commands"
+      };
+    }
     for (const rule of this.rules) {
       if (rule.pattern.test(trimmed)) {
         return {
@@ -1150,8 +1198,8 @@ class ExecPolicy {
       }
     }
     return {
-      decision: "prompt",
-      reason: "Command is not in the automatic allowlist"
+      decision: "allow",
+      reason: "Auto mode allows execution"
     };
   }
 }
@@ -1169,6 +1217,17 @@ class Session {
   mcpManager;
   execPolicy;
   collaborationMode = "default";
+  get permissionMode() {
+    return this.execPolicy.getMode();
+  }
+  setPermissionMode(mode) {
+    this.execPolicy.setMode(mode);
+    if (mode === "plan") {
+      this.collaborationMode = "plan";
+    } else if (this.collaborationMode === "plan") {
+      this.collaborationMode = "default";
+    }
+  }
   history = [];
   activeTurn = null;
   status = "idle";
@@ -1415,6 +1474,22 @@ var applyPatchTool = {
     const filePath = resolve4(ctx.cwd, rawPath);
     const targetContent = typeof args.targetContent === "string" ? args.targetContent : "";
     const replacementContent = String(args.replacementContent ?? "");
+    if (ctx.execPolicy) {
+      const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
+      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: "Error: Cannot mutate files while in Plan Mode. Please present the implementation plan first.",
+          isError: true
+        };
+      }
+      if (evalResult.prompt && ctx.requestApproval) {
+        const approval = await ctx.requestApproval(`Apply patch to: ${rawPath}`, `apply_patch ${rawPath}`);
+        const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
+        if (!allowed) {
+          return { output: `Action rejected by user: apply_patch '${rawPath}'`, isError: true };
+        }
+      }
+    }
     if (!existsSync4(filePath)) {
       if (targetContent) {
         return {
@@ -2049,7 +2124,24 @@ var writeFileTool = {
     required: ["path", "content"]
   },
   async execute(args, ctx) {
-    const filePath = resolve7(ctx.cwd, String(args.path || ""));
+    const rawPath = String(args.path || "");
+    const filePath = resolve7(ctx.cwd, rawPath);
+    if (ctx.execPolicy) {
+      const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
+      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: "Error: Cannot write or mutate files while in Plan Mode. Please present the implementation plan first.",
+          isError: true
+        };
+      }
+      if (evalResult.prompt && ctx.requestApproval) {
+        const approval = await ctx.requestApproval(`Write file: ${rawPath}`, `write_file ${rawPath}`);
+        const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
+        if (!allowed) {
+          return { output: `Action rejected by user: write_file '${rawPath}'`, isError: true };
+        }
+      }
+    }
     try {
       mkdirSync4(dirname4(filePath), { recursive: true });
       writeFileSync3(filePath, String(args.content ?? ""), "utf8");
@@ -5949,8 +6041,8 @@ function getPackageMetadata() {
   if (cachedMetadata) {
     return cachedMetadata;
   }
-  const envVersion = process.env.PIKAA_VERSION || process.env.GROUPY_VERSION || process.env.npm_package_version;
-  const envName = process.env.PIKAA_NAME || process.env.npm_package_name;
+  const envVersion = process.env.PIKAA_VERSION || process.env.GROUPY_VERSION;
+  const envName = process.env.PIKAA_NAME || process.env.GROUPY_NAME;
   if (envVersion) {
     cachedMetadata = {
       name: envName || "pikaa",
@@ -6003,7 +6095,7 @@ function getPackageMetadata() {
   } catch {}
   cachedMetadata = {
     name: "pikaa",
-    version: "0.3.2"
+    version: "0.3.6"
   };
   return cachedMetadata;
 }
@@ -6445,10 +6537,41 @@ ${preview}${more}`);
     console.log();
   }
   static formatClaudeUserPrompt(text) {
-    const cols = typeof process.stdout?.columns === "number" ? process.stdout.columns : 80;
-    const width = Math.min(76, Math.max(48, cols - 6));
-    const pad = Math.max(1, width - (text.length + 5));
-    return `  \x1B[48;2;50;50;52m\x1B[38;2;145;145;150m \u276F \x1B[38;2;255;255;255m\x1B[1m${text}${" ".repeat(pad)}\x1B[0m`;
+    const cols = typeof process.stdout?.columns === "number" && process.stdout.columns > 0 ? process.stdout.columns : 80;
+    const boxWidth = Math.max(20, cols - 2);
+    const contentWidth = Math.max(10, boxWidth - 3);
+    const BG = "\x1B[48;2;43;43;45m";
+    const CHEVRON = "\x1B[38;2;128;128;133m";
+    const TEXT = "\x1B[38;2;240;240;242m";
+    const RESET2 = "\x1B[0m";
+    const rawLines = text.split(`
+`);
+    const wrappedLines = [];
+    for (const rawLine of rawLines) {
+      if (rawLine.length === 0) {
+        wrappedLines.push("");
+        continue;
+      }
+      let current = rawLine;
+      while (current.length > contentWidth) {
+        let breakIdx = current.lastIndexOf(" ", contentWidth);
+        if (breakIdx <= 0) {
+          breakIdx = contentWidth;
+        }
+        wrappedLines.push(current.slice(0, breakIdx));
+        current = current.slice(breakIdx).trimStart();
+      }
+      if (current.length > 0) {
+        wrappedLines.push(current);
+      }
+    }
+    const formatted = wrappedLines.map((line, idx) => {
+      const prefix = idx === 0 ? `${CHEVRON} \u276F ` : `${CHEVRON}   `;
+      const padLen = Math.max(0, contentWidth - line.length);
+      return `  ${BG}${prefix}${TEXT}${line}${" ".repeat(padLen)}${RESET2}`;
+    });
+    return formatted.join(`
+`);
   }
   static formatClaudeAssistantResponse(text) {
     return `  \x1B[38;2;192;202;245m${text}\x1B[0m`;
@@ -6481,12 +6604,49 @@ function ensureKeypressInitialized() {
 class InteractiveLineEditor {
   promptSymbol;
   cwd;
+  mode;
   onInterrupt;
+  onModeChange;
   searchEngine = new FileSearchEngine;
   constructor(options = {}) {
     this.promptSymbol = options.promptSymbol || "  \x1B[38;2;192;202;245m\u276F\x1B[0m ";
     this.cwd = options.cwd || process.cwd();
+    this.mode = options.initialMode || "auto";
     this.onInterrupt = options.onInterrupt;
+    this.onModeChange = options.onModeChange;
+  }
+  getMode() {
+    return this.mode;
+  }
+  setMode(mode) {
+    this.mode = mode;
+    this.onModeChange?.(mode);
+  }
+  cycleMode() {
+    const modes = ["auto", "manual", "accept-edits", "plan"];
+    const nextIdx = (modes.indexOf(this.mode) + 1) % modes.length;
+    const next = modes[nextIdx];
+    this.setMode(next);
+    return next;
+  }
+  cycleModeReverse() {
+    const modes = ["auto", "manual", "accept-edits", "plan"];
+    const nextIdx = (modes.indexOf(this.mode) - 1 + modes.length) % modes.length;
+    const next = modes[nextIdx];
+    this.setMode(next);
+    return next;
+  }
+  getModeLine() {
+    switch (this.mode) {
+      case "auto":
+        return `  \x1B[38;2;255;215;0m\u23F5\u23F5 auto mode on\x1B[0m \x1B[38;2;148;148;148m(shift+tab to cycle) \xB7 \u21E0 for agents\x1B[0m`;
+      case "manual":
+        return `  \x1B[38;2;148;148;148m\u23F8 manual mode on \xB7 ? for shortcuts \xB7 \u21E0 for agents\x1B[0m`;
+      case "accept-edits":
+        return `  \x1B[38;2;175;175;215m\u23F5\u23F5 accept edits on\x1B[0m \x1B[38;2;148;148;148m(shift+tab to cycle) \xB7 \u21E0 for agents\x1B[0m`;
+      case "plan":
+        return `  \x1B[38;2;95;175;175m\u23F8 plan mode on\x1B[0m \x1B[38;2;148;148;148m(shift+tab to cycle) \xB7 \u21E0 for agents\x1B[0m`;
+    }
   }
   async readLine() {
     if (!process.stdin.isTTY) {
@@ -6540,6 +6700,14 @@ class InteractiveLineEditor {
           return [];
         }
       };
+      const getTerminalCols = () => {
+        return typeof process.stdout?.columns === "number" && process.stdout.columns > 0 ? process.stdout.columns : 80;
+      };
+      const getRule = () => {
+        const cols = getTerminalCols();
+        const ruleLen = Math.max(10, cols - 4);
+        return "\u2500".repeat(ruleLen);
+      };
       const ensureVisible = (totalItems, visibleRows) => {
         if (totalItems === 0 || visibleRows === 0) {
           scrollTop = 0;
@@ -6567,37 +6735,39 @@ class InteractiveLineEditor {
         }
       };
       const redraw = () => {
-        clearMenu();
+        process.stdout.write("\x1B[J");
         process.stdout.write(`\r\x1B[2K${this.promptSymbol}${buffer}`);
         const slashMatches = getMatchingCommands();
         const activeFile = getActiveFileQuery();
         const fileMatches = activeFile ? getMatchingFiles(activeFile.query) : [];
         if (buffer.startsWith("/") && !popupDismissed && slashMatches.length > 0) {
-          const BOX_WIDTH = 70;
+          const termCols = getTerminalCols();
+          const BOX_WIDTH = Math.max(20, Math.min(termCols - 4, 120));
           const maxVisible = Math.min(slashMatches.length, 7);
           ensureVisible(slashMatches.length, maxVisible);
           const visibleMatches = slashMatches.slice(scrollTop, scrollTop + maxVisible);
           const menuLines = [];
-          const rule = "\u2500".repeat(Math.min(BOX_WIDTH, 68));
-          const RULE_COLOR = "\x1B[38;2;80;80;88m";
+          const rule = "\u2500".repeat(BOX_WIDTH);
+          const RULE_COLOR2 = "\x1B[38;2;80;80;88m";
           const ACTIVE_COLOR = "\x1B[38;2;225;225;225m";
           const INACTIVE_COLOR = "\x1B[38;2;139;139;144m";
           const RESET2 = "\x1B[0m";
-          menuLines.push(`  ${RULE_COLOR}${rule}${RESET2}`);
+          menuLines.push(`  ${RULE_COLOR2}${rule}${RESET2}`);
+          const maxDescLen = Math.max(10, BOX_WIDTH - 22);
           for (let i = 0;i < visibleMatches.length; i++) {
             const cmd = visibleMatches[i];
             const actualIdx = scrollTop + i;
             const isSelected = actualIdx === selectedIndex;
             const marker = isSelected ? `${ACTIVE_COLOR}\u276F${RESET2}` : " ";
             const rawName = cmd.name.padEnd(16).slice(0, 16);
-            const rawDesc = cmd.description.length > 48 ? cmd.description.slice(0, 45) + "..." : cmd.description;
+            const rawDesc = cmd.description.length > maxDescLen ? cmd.description.slice(0, maxDescLen - 3) + "..." : cmd.description;
             if (isSelected) {
               menuLines.push(`  ${marker} \x1B[1m${ACTIVE_COLOR}${rawName}${RESET2}  \x1B[1m${ACTIVE_COLOR}${rawDesc}${RESET2}`);
             } else {
               menuLines.push(`  ${marker} ${INACTIVE_COLOR}${rawName}${RESET2}  ${INACTIVE_COLOR}${rawDesc}${RESET2}`);
             }
           }
-          menuLines.push(`  ${RULE_COLOR}${rule}${RESET2}`);
+          menuLines.push(`  ${RULE_COLOR2}${rule}${RESET2}`);
           for (const line of menuLines) {
             process.stdout.write(`
 \x1B[2K${line}`);
@@ -6605,18 +6775,20 @@ class InteractiveLineEditor {
           renderedMenuLines = menuLines.length;
           process.stdout.write(`\x1B[${renderedMenuLines}A`);
         } else if (activeFile && !popupDismissed && fileMatches.length > 0) {
-          const BOX_WIDTH = 70;
+          const termCols = getTerminalCols();
+          const BOX_WIDTH = Math.max(20, Math.min(termCols - 4, 120));
           const maxVisible = Math.min(fileMatches.length, 7);
           ensureVisible(fileMatches.length, maxVisible);
           const visibleMatches = fileMatches.slice(scrollTop, scrollTop + maxVisible);
           const menuLines = [];
           menuLines.push(`  ${style.dim("\u250C\u2500\u2500")} ${style.brandBold("Files")} ${style.dim("\u2500".repeat(Math.max(10, BOX_WIDTH - 9)) + "\u2510")}`);
+          const maxPathLen = Math.max(10, BOX_WIDTH - 8);
           for (let i = 0;i < visibleMatches.length; i++) {
             const filePath = visibleMatches[i];
             const actualIdx = scrollTop + i;
             const isSelected = actualIdx === selectedIndex;
             const marker = isSelected ? style.brand("\u276F") : " ";
-            const rawPath = filePath.length > 62 ? "..." + filePath.slice(filePath.length - 59) : filePath.padEnd(62);
+            const rawPath = filePath.length > maxPathLen ? "..." + filePath.slice(filePath.length - (maxPathLen - 3)) : filePath.padEnd(maxPathLen);
             const coloredPath = isSelected ? style.brandBold(rawPath) : style.cyan(rawPath);
             menuLines.push(`  ${style.dim("\u2502")} ${marker} ${coloredPath} ${style.dim("\u2502")}`);
           }
@@ -6641,6 +6813,15 @@ class InteractiveLineEditor {
           }
           renderedMenuLines = menuLines.length;
           process.stdout.write(`\x1B[${renderedMenuLines}A`);
+        } else {
+          const RULE_COLOR2 = "\x1B[38;2;60;60;68m";
+          const bottomRule = `  ${RULE_COLOR2}${getRule()}\x1B[0m`;
+          const modeLine = this.getModeLine();
+          process.stdout.write(`
+\x1B[2K${bottomRule}
+\x1B[2K${modeLine}`);
+          renderedMenuLines = 2;
+          process.stdout.write(`\x1B[2A`);
         }
         const visiblePromptLength = this.promptSymbol.replace(/\x1b\[[0-9;]*m/g, "").length;
         const cursorCol = visiblePromptLength + cursor;
@@ -6650,7 +6831,16 @@ class InteractiveLineEditor {
           process.stdout.write("\r");
         }
       };
+      const onResize = () => {
+        redraw();
+      };
+      if (process.stdout && typeof process.stdout.on === "function") {
+        process.stdout.on("resize", onResize);
+      }
       const cleanupAndResolve = (result) => {
+        if (process.stdout && typeof process.stdout.removeListener === "function") {
+          process.stdout.removeListener("resize", onResize);
+        }
         clearMenu();
         process.stdin.removeListener("keypress", onKeypress);
         if (process.stdin.isTTY) {
@@ -6659,11 +6849,11 @@ class InteractiveLineEditor {
           } catch {}
         }
         if (result.trim().length > 0 && !result.startsWith("/")) {
-          process.stdout.write(`\r\x1B[2K${CliFormatter.formatClaudeUserPrompt(result)}
+          process.stdout.write(`\x1B[1A\r\x1B[2K${CliFormatter.formatClaudeUserPrompt(result)}
 
 `);
         } else {
-          process.stdout.write(`
+          process.stdout.write(`\x1B[1A\r\x1B[2K
 `);
         }
         resolve18(result);
@@ -6681,6 +6871,9 @@ class InteractiveLineEditor {
             redraw();
             return;
           }
+          if (process.stdout && typeof process.stdout.removeListener === "function") {
+            process.stdout.removeListener("resize", onResize);
+          }
           clearMenu();
           if (process.stdin.isTTY) {
             try {
@@ -6731,6 +6924,12 @@ class InteractiveLineEditor {
           cleanupAndResolve(buffer);
           return;
         }
+        const isShiftTab = key.name === "tab" && Boolean(key.shift) || key.name === "backtab" || key.sequence === "\x1B[Z" || _str === "\x1B[Z";
+        if (isShiftTab) {
+          this.cycleMode();
+          redraw();
+          return;
+        }
         if (key.name === "tab") {
           if (activeFile && !popupDismissed && fileMatches.length > 0) {
             const chosen = fileMatches[selectedIndex] || fileMatches[0];
@@ -6753,8 +6952,14 @@ class InteractiveLineEditor {
               scrollTop = 0;
               popupDismissed = false;
               redraw();
+              return;
             }
           }
+          if (buffer.trim().length === 0) {
+            this.cycleMode();
+            redraw();
+            return;
+          }
           return;
         }
         if (key.name === "up") {
@@ -6818,7 +7023,11 @@ class InteractiveLineEditor {
         }
       };
       process.stdin.on("keypress", onKeypress);
-      process.stdout.write(this.promptSymbol);
+      const RULE_COLOR = "\x1B[38;2;60;60;68m";
+      process.stdout.write(`
+  ${RULE_COLOR}${getRule()}\x1B[0m
+`);
+      redraw();
     });
   }
 }
@@ -7550,6 +7759,11 @@ var AVAILABLE_SLASH_COMMANDS = [
   { name: "/reasoning", description: "Toggle internal reasoning chain visibility" },
   { name: "/login", description: "Authenticate with backend provider" },
   { name: "/whoami", description: "Check backend authentication status" },
+  { name: "/mode", description: "Cycle or set execution permission mode (auto, manual, accept-edits, plan)" },
+  { name: "/auto", description: "Switch to Auto Mode (tools execute automatically)" },
+  { name: "/manual", description: "Switch to Manual Mode (all tools require user confirmation)" },
+  { name: "/accept-edits", description: "Switch to Accept Edits Mode (file edits auto-approved, shell prompts)" },
+  { name: "/plan", description: "Switch to Plan Mode (read-only planning, mutations blocked)" },
   { name: "/skills", description: "List domain skills in workspace & global" },
   { name: "/memories", description: "View learned preferences & memories" },
   { name: "/worktrees", description: "List active isolated Git Worktrees" },
@@ -7601,6 +7815,37 @@ async function handleSlashCommand(input, ctx) {
     case "/roles":
       await handleRolesCommand(ctx, args[0]);
       return true;
+    case "/mode":
+    case "/modes":
+    case "/permission":
+    case "/permissions":
+      await handleModeCommand(ctx, args[0]);
+      return true;
+    case "/auto":
+      ctx.session.setPermissionMode("auto");
+      console.log(`
+  \x1B[38;2;255;215;0m\u23F5\u23F5 Switched to Auto Mode (tools execute automatically)\x1B[0m
+`);
+      return true;
+    case "/manual":
+      ctx.session.setPermissionMode("manual");
+      console.log(`
+  \x1B[38;2;148;148;148m\u23F8 Switched to Manual Mode (all tools require user confirmation)\x1B[0m
+`);
+      return true;
+    case "/accept-edits":
+    case "/acceptedits":
+      ctx.session.setPermissionMode("accept-edits");
+      console.log(`
+  \x1B[38;2;175;175;215m\u23F5\u23F5 Switched to Accept Edits Mode (file edits auto-approved, shell prompts)\x1B[0m
+`);
+      return true;
+    case "/plan":
+      ctx.session.setPermissionMode("plan");
+      console.log(`
+  \x1B[38;2;95;175;175m\u23F8 Switched to Plan Mode (read-only planning, mutations blocked)\x1B[0m
+`);
+      return true;
     case "/agents":
       printAgents(ctx);
       return true;
@@ -8517,6 +8762,84 @@ function printReleaseNotes() {
   console.log("  " + ROSE2 + "\u2514" + "\u2500".repeat(totalInnerWidth) + "\u2518" + RESET2);
   console.log("");
 }
+async function handleModeCommand(ctx, arg) {
+  const validModes = [
+    {
+      mode: "auto",
+      title: "Auto Mode",
+      desc: "Tools run automatically without confirmation (fastest autonomous workflow)",
+      glyph: "\u23F5\u23F5",
+      color: "\x1B[38;2;255;215;0m"
+    },
+    {
+      mode: "manual",
+      title: "Manual Mode",
+      desc: "Every file edit and shell command asks for user confirmation",
+      glyph: "\u23F8",
+      color: "\x1B[38;2;148;148;148m"
+    },
+    {
+      mode: "accept-edits",
+      title: "Accept Edits Mode",
+      desc: "File edits are auto-approved, but shell commands require approval",
+      glyph: "\u23F5\u23F5",
+      color: "\x1B[38;2;175;175;215m"
+    },
+    {
+      mode: "plan",
+      title: "Plan Mode",
+      desc: "Read-only mode. Blocks all mutations and focuses strictly on planning",
+      glyph: "\u23F8",
+      color: "\x1B[38;2;95;175;175m"
+    }
+  ];
+  const currentMode = ctx.session.permissionMode;
+  if (arg) {
+    const normalized = arg.trim().toLowerCase();
+    const match = validModes.find((m) => m.mode === normalized || m.mode.replace("-", "") === normalized);
+    if (match) {
+      ctx.session.setPermissionMode(match.mode);
+      console.log(`
+  ${match.color}${match.glyph} Switched to ${match.title}\x1B[0m
+  ${style.dim(match.desc)}
+`);
+      return;
+    }
+  }
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    console.log(`
+  Current Permission Mode: ${style.bold(currentMode)}`);
+    for (const m of validModes) {
+      const active = m.mode === currentMode ? " (active)" : "";
+      console.log(`  \u2022 ${m.title}${active}: ${m.desc}`);
+    }
+    console.log();
+    return;
+  }
+  const items = validModes.map((m) => ({
+    id: m.mode,
+    label: `${m.glyph} ${m.title}`,
+    badge: m.mode === currentMode ? "ACTIVE" : undefined,
+    description: m.desc,
+    checked: m.mode === currentMode
+  }));
+  const res = await promptInteractiveList({
+    title: "\uD83C\uDF9B\uFE0F Select Execution Permission Mode (Shift+Tab in prompt to cycle)",
+    items,
+    mode: "select",
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Enter: switch mode \xB7 Esc: cancel"
+  });
+  if (res.action === "select" && res.selectedItem) {
+    const chosen = validModes.find((m) => m.mode === res.selectedItem?.id);
+    if (chosen) {
+      ctx.session.setPermissionMode(chosen.mode);
+      console.log(`
+  ${chosen.color}${chosen.glyph} Switched to ${chosen.title}\x1B[0m
+  ${style.dim(chosen.desc)}
+`);
+    }
+  }
+}
 
 // src/cli/ui/markdown.ts
 class MarkdownHighlighter {
@@ -9124,6 +9447,10 @@ class CliRepl {
     }).catch(() => {});
     const editor = new InteractiveLineEditor({
       cwd: this.session.cwd,
+      initialMode: this.session.permissionMode,
+      onModeChange: (newMode) => {
+        this.session.setPermissionMode(newMode);
+      },
       onInterrupt: () => {
         if (this.isProcessing) {
           const activeTurn = this.session.getActiveTurn();

package/dist/index.js

@@ -1648,6 +1648,22 @@ var applyPatchTool = {
     const filePath = resolve2(ctx.cwd, rawPath);
     const targetContent = typeof args.targetContent === "string" ? args.targetContent : "";
     const replacementContent = String(args.replacementContent ?? "");
+    if (ctx.execPolicy) {
+      const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
+      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: "Error: Cannot mutate files while in Plan Mode. Please present the implementation plan first.",
+          isError: true
+        };
+      }
+      if (evalResult.prompt && ctx.requestApproval) {
+        const approval = await ctx.requestApproval(`Apply patch to: ${rawPath}`, `apply_patch ${rawPath}`);
+        const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
+        if (!allowed) {
+          return { output: `Action rejected by user: apply_patch '${rawPath}'`, isError: true };
+        }
+      }
+    }
     if (!existsSync2(filePath)) {
       if (targetContent) {
         return {
@@ -1704,9 +1720,17 @@ var applyPatchTool = {
 // src/security/exec-policy.ts
 class ExecPolicy {
   rules = [];
-  constructor() {
+  mode = "auto";
+  constructor(initialMode = "auto") {
+    this.mode = initialMode;
     this.initDefaultRules();
   }
+  getMode() {
+    return this.mode;
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
   initDefaultRules() {
     this.addRule(/^(git\s+(status|log|diff|branch|show|rev-parse))/i, "allow", "Safe git query");
     this.addRule(/^(ls|dir|cat|type|grep|rg|find|pwd|echo|head|tail|wc|which|where)\b/i, "allow", "Safe read-only shell command");
@@ -1718,8 +1742,47 @@ class ExecPolicy {
   addRule(pattern, decision, description) {
     this.rules.unshift({ pattern, decision, description });
   }
+  shouldPromptFileEdit(filePath) {
+    if (this.mode === "plan") {
+      return {
+        prompt: false,
+        isPlanBlocked: true,
+        reason: "Plan Mode is active. Mutating files is not allowed while planning."
+      };
+    }
+    if (this.mode === "manual") {
+      return {
+        prompt: true,
+        reason: `Manual mode requires approval to modify '${filePath || "file"}'`
+      };
+    }
+    return { prompt: false };
+  }
   evaluate(command) {
     const trimmed = command.trim();
+    if (this.mode === "plan") {
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|which|where)\b/i.test(trimmed);
+      if (isReadOnly) {
+        return { decision: "allow", reason: "Read-only inspection allowed in Plan mode" };
+      }
+      return { decision: "deny", reason: "Cannot execute mutating shell commands in Plan mode" };
+    }
+    if (this.mode === "manual") {
+      return {
+        decision: "prompt",
+        reason: "Manual mode requires confirmation for all shell commands"
+      };
+    }
+    if (this.mode === "accept-edits") {
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|bun\s+test|npm\s+test)\b/i.test(trimmed);
+      if (isReadOnly) {
+        return { decision: "allow", reason: "Safe read-only command in accept-edits mode" };
+      }
+      return {
+        decision: "prompt",
+        reason: "Accept-edits mode requires approval for active shell commands"
+      };
+    }
     for (const rule of this.rules) {
       if (rule.pattern.test(trimmed)) {
         return {
@@ -1729,8 +1792,8 @@ class ExecPolicy {
       }
     }
     return {
-      decision: "prompt",
-      reason: "Command is not in the automatic allowlist"
+      decision: "allow",
+      reason: "Auto mode allows execution"
     };
   }
 }
@@ -2316,7 +2379,24 @@ var writeFileTool = {
     required: ["path", "content"]
   },
   async execute(args, ctx) {
-    const filePath = resolve5(ctx.cwd, String(args.path || ""));
+    const rawPath = String(args.path || "");
+    const filePath = resolve5(ctx.cwd, rawPath);
+    if (ctx.execPolicy) {
+      const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
+      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: "Error: Cannot write or mutate files while in Plan Mode. Please present the implementation plan first.",
+          isError: true
+        };
+      }
+      if (evalResult.prompt && ctx.requestApproval) {
+        const approval = await ctx.requestApproval(`Write file: ${rawPath}`, `write_file ${rawPath}`);
+        const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
+        if (!allowed) {
+          return { output: `Action rejected by user: write_file '${rawPath}'`, isError: true };
+        }
+      }
+    }
     try {
       mkdirSync4(dirname3(filePath), { recursive: true });
       writeFileSync3(filePath, String(args.content ?? ""), "utf8");
@@ -3881,6 +3961,7 @@ async function runTurn(session, turnContext, input) {
             signal,
             execPolicy: session.execPolicy,
             mode: session.collaborationMode,
+            permissionMode: session.permissionMode,
             onPlanUpdate: (plan2, explanation) => {
               session.emitEvent({
                 type: "PlanUpdated",
@@ -4041,6 +4122,17 @@ class Session {
   mcpManager;
   execPolicy;
   collaborationMode = "default";
+  get permissionMode() {
+    return this.execPolicy.getMode();
+  }
+  setPermissionMode(mode) {
+    this.execPolicy.setMode(mode);
+    if (mode === "plan") {
+      this.collaborationMode = "plan";
+    } else if (this.collaborationMode === "plan") {
+      this.collaborationMode = "default";
+    }
+  }
   history = [];
   activeTurn = null;
   status = "idle";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikaa-ai/pikaa",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "PIKAA CLI - AI coding agent that runs locally in your terminal.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/templates/base/groupy_prompt.md

@@ -15,9 +15,75 @@ You are Groupy, an expert autonomous AI coding assistant. You are running as a c
     * If the changes are in files you've touched recently, you should read carefully and understand how you can work with the changes rather than reverting them.
     * If the changes are in unrelated files, just ignore them and don't revert them.
 - Do not amend a commit unless explicitly requested to do so.
-- While you are working, you might notice unexpected changes that you didn't make. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed.
 - **NEVER** use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested or approved by the user.
 
+## Adaptive Task Routing (Automatic Complexity Detection)
+
+1. **Small / Standard Tasks (Single component, straightforward, < 3 files)**:
+   - Proceed directly to execution with zero overhead. Do not create heavy plans or ask trivial confirmation questions.
+   - Code surgically and verify with automated tests.
+
+2. **Large / Complex / Ambiguous Tasks (> 3 files, architectural overhaul, new subsystem)**:
+   - **Step 1 (Auto-Plan)**: Outline a brief step-by-step Implementation Plan before modifying files.
+   - **Step 2 (Clarify Ambiguity & Present Choices)**: If there are architectural trade-offs or underspecified requirements, pause and present numbered choices with Option 1 marked as `(Recommended)`.
+   - **Step 3 (Execute & Delegate)**: Once the user confirms, execute systematically. Autonomously spawn specialized sub-agents (`spawn_agent`) for independent sub-tasks (e.g. `security-auditor`, `frontend-designer`, `tester`, `researcher`).
+   - **Step 4 (Verify)**: Run full build and test suites, automatically repairing any failures before concluding.
+
+## Clarifications, Decision Branching & Recommendations
+
+1. **Avoid Trivial Questions**:
+   - For routine decisions (naming, syntax, sensible standard defaults), use industry best practices and proceed autonomously without bothering the user.
+
+2. **When to Pause & Clarify (Ambiguity & Trade-offs)**:
+   - Pause and ask if you encounter:
+     * Significantly underspecified requirements (e.g., storage driver, auth strategy, deployment target).
+     * Potential breaking changes affecting existing modules.
+     * Large architectural choices with distinct trade-offs.
+
+3. **Recommendation Format**:
+   - Always format choices as clear, numbered options (`1.`, `2.`, `3.`).
+   - Place your best technical recommendation as Option 1 prefixed with `(Recommended)`.
+   - Keep options concise so the user can reply instantly with a single number.
+
+## Codebase Discovery & Execution Strategy
+
+1. **Broad Exploration ("pelajari project ini / repo ini tentang apa")**:
+   - Inspect ONLY root configs (`package.json`, `Cargo.toml`, `go.mod`, `pyproject.toml`, etc.), `README.md`, and top-level directory tree.
+   - Deliver a concise Architecture Overview (Tech stack, folder hierarchy, main entry points).
+   - Do NOT read full component or implementation files during initial reconnaissance. Stop and ask the user what to build or investigate next.
+
+2. **Direct Feature Requests ("buat fitur X")**:
+   - Do NOT scan or read unrelated files across the repo.
+   - Use `grep_search` or `find_files` to pinpoint the exact target area.
+   - Read ONLY 1-2 existing reference files to understand established patterns, naming conventions, and shared utilities (avoid reinventing the wheel).
+   - Implement the minimal, clean, and robust code needed to satisfy the request.
+
+3. **Bug Fixes & Diagnostics ("kenapa error X / perbaiki bug Y")**:
+   - Trace from the reported symptom using `grep_search` to find all callers and the shared function.
+   - Fix the root cause in the shared module once, rather than applying band-aid patches across callers.
+
+## Mandatory Verification, Testing & Self-Repair Loop
+
+Before considering any task complete, you MUST execute the following verification steps:
+
+1. **Write Automated Tests**:
+   - For any non-trivial logic, new feature, or bug fix, write a clean and targeted test suite (or update existing tests).
+   - Ensure the test covers edge cases and specifically verifies that the bug cannot regress.
+
+2. **Run Build & Test Validation (Platform & Stack Specific)**:
+   Detect the project type and execute the appropriate validation command via terminal:
+   - **TypeScript / JavaScript (Node, Bun, Deno)**: Run `bun test` / `npm test`, `tsc --noEmit`, or `npm run build`.
+   - **Rust**: Run `cargo check`, `cargo test`, and `cargo build`.
+   - **Go**: Run `go test ./...` and `go build`.
+   - **Python**: Run `pytest` or `python -m unittest`, and verify syntax with `python -m py_compile <files>` or `mypy`.
+   - **Java / Kotlin**: Run `./gradlew test` / `mvn test` and verify compile.
+   - **C / C++ / C#**: Run project build / test targets (`dotnet test`, `cmake --build`, `make test`).
+
+3. **Autonomous Self-Repair (Do Not Stop on Error)**:
+   - If tests fail, types mismatch, or the build produces compilation errors, do NOT stop and report failure immediately.
+   - Inspect the compiler/runtime stack trace, diagnose the exact failure, apply the fix, and re-run verification until all checks pass cleanly.
+   - Only conclude your turn once the code compiles, builds, and passes all tests.
+
 ## Skills & Autonomous Domain Knowledge
 
 You have access to specialized domain skills listed in `<available_skills>`.