@cydm/pie 1.0.26 → 1.0.27

package/dist/cli.js

@@ -45727,6 +45727,45 @@ var ModelRegistry = class {
 // src/core/settings-manager.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
+
+// src/tool-set.ts
+var DEFAULT_TOOL_SET = "lean";
+var LEAN_CODING_TOOL_NAMES = [
+  "read_file",
+  "edit_file",
+  "write_file",
+  "bash"
+];
+var CLI_DEFAULT_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "read_file",
+  "write_file",
+  "edit_file",
+  "list_dir",
+  "grep_text",
+  "find_files",
+  "bash",
+  "web_research",
+  "web_search",
+  "web_fetch",
+  "code_intel"
+]);
+var LEAN_CODING_TOOL_NAME_SET = new Set(LEAN_CODING_TOOL_NAMES);
+function normalizeDefaultToolSet(value) {
+  return value === "full" ? "full" : DEFAULT_TOOL_SET;
+}
+function selectDefaultTools(tools, defaultSet) {
+  if (defaultSet === "full") {
+    return [...tools];
+  }
+  return tools.filter(
+    (tool) => !CLI_DEFAULT_TOOL_NAMES.has(tool.name) || LEAN_CODING_TOOL_NAME_SET.has(tool.name)
+  );
+}
+function formatDefaultToolSet(defaultSet) {
+  return defaultSet === "full" ? "Full" : "Lean";
+}
+
+// src/core/settings-manager.ts
 var SettingsManager = class {
   settingsPath;
   legacyConfigPath;
@@ -45815,6 +45854,16 @@ var SettingsManager = class {
     }
     return "auto";
   }
+  getDefaultToolSet() {
+    return normalizeDefaultToolSet(this.settings.tools?.defaultSet);
+  }
+  setDefaultToolSet(defaultSet) {
+    this.settings.tools = {
+      ...this.settings.tools,
+      defaultSet
+    };
+    this.writeSettings();
+  }
   // ==========================================================================
   // Extension enablement (user ~/.pie/settings.json + project ./.pie/settings.json)
   // ==========================================================================
@@ -60224,6 +60273,34 @@ var SettingsSelectorComponent = class extends Container {
           }
         )
       },
+      {
+        id: "tools",
+        label: "Tools",
+        description: "Default model-visible tool set",
+        currentValue: config.defaultToolSet,
+        submenu: (currentValue, done) => new SelectSubmenu(
+          "Default Tools",
+          "Choose which built-in tools are visible in new coding sessions",
+          [
+            {
+              value: "lean",
+              label: "Lean",
+              description: "read_file, edit_file, write_file, bash"
+            },
+            {
+              value: "full",
+              label: "Full",
+              description: "All built-in tools, including search, web, and code intel"
+            }
+          ],
+          currentValue,
+          (value) => {
+            callbacks.onDefaultToolSetChange(value);
+            done(value);
+          },
+          () => done()
+        )
+      },
       {
         id: "extensions",
         label: "Extensions",
@@ -63566,10 +63643,7 @@ async function handleSkillsReload(host) {
     const result = loadSkills({ builtinDir, userDir, projectDir });
     host.skills = result.skills;
     host.skillsSection = formatSkillsForPrompt(host.skills);
-    const rebuiltTools = host.rebuildSkillAwareTools(host.agent.state.tools);
-    host.agent.state.tools = rebuiltTools.currentTools;
-    host.allTools = [...rebuiltTools.currentTools];
-    host.originalTools = [...rebuiltTools.originalTools];
+    host.applyRuntimeToolMode(host.allTools.length > 0 ? host.allTools : host.agent.state.tools);
     host.updateSystemPromptTools();
     for (const skill of host.skills) {
       const skillPath = ["skills", `skill:${skill.name}`];
@@ -63614,7 +63688,8 @@ function showSettingsSelector(host) {
         availableThemes: getAvailableThemes(),
         currentModel: currentModelId,
         availableModels,
-        yoloMode: host.yoloMode
+        yoloMode: host.yoloMode,
+        defaultToolSet: host.options.settingsManager.getDefaultToolSet()
       },
       {
         onThinkingLevelChange: (level) => {
@@ -63643,6 +63718,10 @@ function showSettingsSelector(host) {
             host.showError(`Failed to switch model: ${err}`);
           }
         },
+        onDefaultToolSetChange: (defaultToolSet) => {
+          host.options.settingsManager.setDefaultToolSet(defaultToolSet);
+          host.showStatus(`Default tools: ${formatDefaultToolSet(defaultToolSet)} (restart Pie to apply)`);
+        },
         onYoloToggle: async () => {
           await host.handleYoloCommand();
           done();
@@ -64144,6 +64223,10 @@ function registerBuiltinCommands(host) {
     description: "Change theme",
     handler: () => host.showSettingsSelector()
   });
+  commandTree.register(["settings", "tools"], {
+    description: "Choose the default model-visible tool set",
+    handler: () => host.showSettingsSelector()
+  });
   commandTree.register(["settings", "thinking"], {
     description: "Set thinking level (off/minimal/low/medium/high/xhigh)",
     handler: (_2, args) => host.handleThinkingCommand(args)
@@ -66994,7 +67077,6 @@ function buildCodingAgentGuidelinesSection(tools = []) {
   const hasRead = toolNames.has("read_file");
   const hasWrite = toolNames.has("write_file");
   const hasEdit = toolNames.has("edit_file");
-  const hasList = toolNames.has("list_dir");
   const hasGrep = toolNames.has("grep_text");
   const hasFind = toolNames.has("find_files");
   const hasBash = toolNames.has("bash");
@@ -67004,68 +67086,38 @@ function buildCodingAgentGuidelinesSection(tools = []) {
   const hasCodeIntel = toolNames.has("code_intel");
   const hasTodo = toolNames.has("manage_todo_list");
   const guidelines = [
-    "Complete coding tasks by modifying or creating files when needed; do not stop at analysis."
+    "Complete coding tasks by making the needed file changes; do not stop at analysis."
   ];
-  if (hasRead || hasList || hasGrep || hasFind) {
-    guidelines.push("Explore with targeted search and relevant file reads; avoid repeated broad directory listings.");
-    guidelines.push("Prefer first-class Pie tools for the task's semantic intent before lower-level shell preprocessing.");
-  }
-  if (hasGrep || hasFind || hasList) {
-    guidelines.push("Prefer grep_text, find_files, and list_dir for workspace exploration when they are sufficient.");
-  }
-  if (hasGrep) {
-    guidelines.push("Use grep_text outputMode='files_with_matches' to find candidate files, outputMode='count' to estimate impact, and outputMode='content' when you need matching lines and context.");
-    guidelines.push("After a broad grep_text search, narrow the path, glob, pattern, outputMode, offset, or limit instead of repeating the same broad search.");
-  }
-  if (hasWebResearch) {
-    guidelines.push("Use web_research for general public web research, current information, official docs, news, releases, issues, or webpage summaries; it searches, fetches, and returns cited sources.");
-    guidelines.push("When web_research returns fetched sources that answer the request, synthesize the answer from that pack instead of calling web_search or web_fetch again.");
-  }
-  if (hasWebSearch && !hasWebResearch) {
-    guidelines.push("Use web_search for public web research and grep_text/find_files/list_dir for local workspace search.");
-  }
-  if (hasWebFetch && !hasWebResearch) {
-    guidelines.push("After web_search identifies a public source, use web_fetch to read the chosen URL before relying on it; also use web_fetch for user-supplied URLs.");
-  } else if (hasWebResearch && hasWebSearch && hasWebFetch) {
-    guidelines.push("Use web_search and web_fetch directly only when you need low-level control over exact queries or URLs.");
-  }
-  if (hasCodeIntel) {
-    guidelines.push("Use code_intel for JS/TS diagnostics, definitions, references, symbols, or hover when type or symbol information matters before editing.");
-  }
   if (hasRead && hasEdit) {
-    guidelines.push("Read the current file before edit_file changes, then use a precise unique replacement.");
+    guidelines.push("Read the current file before edit_file; use precise replacements and batch related edits when possible.");
   }
-  if (hasRead) {
-    guidelines.push("Use read_file offset/limit for large files; if read_file says a range is unchanged, do not repeat the same read and choose a different range or search instead.");
-    guidelines.push("Use read_file directly for media and documents when the file-understanding route is available.");
+  if (hasGrep || hasFind) {
+    guidelines.push("Use targeted search to locate files, then read only the ranges needed for the edit.");
   }
-  if (hasEdit) {
-    guidelines.push("If edit_file fails because text is missing, read the current file and retry with exact text copied from the latest file contents.");
-    guidelines.push("If edit_file fails because text is not unique, read the current file and retry with a larger exact block, or set replaceAll to true if every occurrence should be replaced.");
+  if (hasRead && !hasEdit) {
+    guidelines.push("Read only the relevant ranges; avoid repeating unchanged reads.");
   }
   if (hasWrite) {
-    guidelines.push("Use write_file for new files or true complete rewrites; before overwriting an existing file, read the current full file with read_file, and prefer edit_file for targeted changes.");
+    guidelines.push("Use write_file for new files or true complete rewrites; prefer edit_file for targeted changes.");
   }
   if (hasBash) {
-    guidelines.push("Pass only executable shell commands to bash, not numbered plan items, headings, or prose.");
     if (hasWrite || hasEdit) {
-      guidelines.push("Do not use shell redirection, cat > file, tee, or heredoc to create or overwrite files when write_file or edit_file can do it; never use Bash to bypass write_file overwrite guards.");
+      guidelines.push("Use file tools for file writes; do not use shell redirection or heredocs to bypass write_file/edit_file guards.");
     }
-    guidelines.push("If bash times out or truncates output, adjust the command or inspect the reported full output path instead of repeating the same command.");
+    guidelines.push("Use bash for tests, builds, and inspection commands; if a command fails or times out, change the approach instead of repeating it.");
+  }
+  if (hasWebResearch || hasWebSearch || hasWebFetch) {
+    guidelines.push("Use web tools only when current or external public information is required.");
+  }
+  if (hasCodeIntel) {
+    guidelines.push("Use code_intel when type, diagnostic, definition, or reference information would materially reduce code-reading churn.");
   }
   if (hasTodo) {
-    guidelines.push("Use manage_todo_list only for multi-step work: create the list, complete only the current item when it is genuinely done, and let the tool advance the next item.");
-    guidelines.push("Do not complete a todo item while implementation is partial, tests or verification are failing, or the required verification has not run.");
+    guidelines.push("Use manage_todo_list only for genuinely multi-step work, and mark items done only after the work is complete.");
   }
   guidelines.push(
-    "Once the root cause or required change is clear, make a small concrete edit instead of continuing unrelated exploration.",
-    "Treat task-relative paths as relative to the current working directory; do not prefix paths with .pie unless the task explicitly names .pie.",
-    "Prefer existing repository or task test commands over ad-hoc smoke checks; self-authored checks are useful only before running the authoritative local test.",
-    "Read test or error output carefully and patch the failing code path directly before doing more broad debugging.",
-    "When writing a module or library file, implement and export the exact functions or API names the task asks for; do not only write a standalone script.",
-    "For multi-step work, keep checkpoints brief and avoid progress reports after every sub-step; batch related edits and advance.",
-    "When the provided public verification command passes, stop immediately and let the harness run any further checks.",
-    "Stop once the requested work is complete and verification is satisfactory; answer with one short final sentence and do not keep rechecking already-passed work."
+    "Run the relevant existing test or build after changes; if it passes, stop and report the result.",
+    "Keep task-relative paths relative to the current working directory."
   );
   return `## Guidelines
 
@@ -67081,7 +67133,7 @@ When the user asks about Pie itself, its extensions, skills, TUI, model configur
 function buildCliSystemPrompt(options) {
   const tools = options.tools.map((tool) => ({
     name: tool.name,
-    description: tool.description ?? ""
+    description: ""
   }));
   return [
     options.customPrompt?.trim() || "You are Pie, a helpful AI coding assistant.",
@@ -68797,12 +68849,18 @@ async function loadInteractiveExtensions(host) {
     }
   }
   const extensionTools = convertExtensionTools(extensions);
-  host.agent.state.tools.push(...extensionTools);
-  host.agent.state.tools = wrapToolsWithExtensions(host.agent.state.tools, host.extensionRunner);
+  const activeTools = [...host.agent.state.tools, ...extensionTools];
+  host.agent.state.tools = wrapToolsWithExtensions(activeTools, host.extensionRunner);
+  const availableTools = [
+    ...host.allTools.length > 0 ? host.allTools : host.originalTools.length > 0 ? host.originalTools : host.agent.state.tools,
+    ...extensionTools
+  ];
+  host.allTools = wrapToolsWithExtensions(availableTools, host.extensionRunner);
+  host.originalTools = [...host.allTools];
   if (host.options.compositionTrace) {
     recordCliCompositionStep(host.options.compositionTrace, {
       id: "extensions_tool_wrapping",
-      inputSummary: `baseTools=${host.agent.state.tools.length - extensionTools.length} extensionPaths=${host.options.extensionPaths?.length ?? 0}`,
+      inputSummary: `baseTools=${host.agent.state.tools.length - extensionTools.length} availableTools=${host.allTools.length - extensionTools.length} extensionPaths=${host.options.extensionPaths?.length ?? 0}`,
       outputSummary: `extensions=${extensions.length}`,
       toolCount: host.agent.state.tools.length,
       extensionWrapping: {
@@ -68812,8 +68870,6 @@ async function loadInteractiveExtensions(host) {
       }
     });
   }
-  host.allTools = [...host.agent.state.tools];
-  host.originalTools = [...host.agent.state.tools];
   host.updateSystemPromptTools();
   if (process.env.PIE_VERBOSE) {
     console.error("[System Prompt] Tools section updated:");
@@ -68955,7 +69011,8 @@ var InteractiveMode = class {
     this.sessionManager = options.sessionManager;
     this.sessionTrace = new SessionTraceWriter(options.sessionTraceDir, this.sessionManager);
     this.skills = options.skills;
-    this.originalTools = [...options.tools];
+    this.allTools = [...options.allTools];
+    this.originalTools = [...options.allTools];
     this.skillsSection = formatSkillsForPrompt(options.skills);
     this.knowledgeSection = buildCliProjectContextSection(options.cwd);
   }
@@ -69077,8 +69134,10 @@ var InteractiveMode = class {
     const rebuilt = this.rebuildSkillAwareTools(completeToolSet);
     const currentTools = this.extensionRunner ? wrapToolsWithExtensions(rebuilt.currentTools, this.extensionRunner) : rebuilt.currentTools;
     const originalTools = this.extensionRunner ? wrapToolsWithExtensions(rebuilt.originalTools, this.extensionRunner) : rebuilt.originalTools;
+    const defaultToolSet = this.options.settingsManager.getDefaultToolSet();
+    const defaultTools = selectDefaultTools(currentTools, defaultToolSet);
     const activeTools = selectToolsForRuntimeMode(
-      currentTools,
+      defaultTools,
       this.planModeEnabled ? "plan" : "normal"
     );
     this.agent.setTools(activeTools);
@@ -69641,15 +69700,17 @@ async function composeCliRuntime(params) {
     outputSummary: summarizeToolNames(rawTools),
     toolCount: rawTools.length
   });
-  const tools = createPolicyEnforcedTools(rawTools, {
+  const allTools = createPolicyEnforcedTools(rawTools, {
     getContext: () => ({ mode: "normal", confirmationPolicy: "allow" })
   });
+  const defaultToolSet = settingsManager.getDefaultToolSet();
+  const tools = selectDefaultTools(allTools, defaultToolSet);
   recordCliCompositionStep(compositionTrace, {
     id: "policy_filtering",
     inputSummary: `tools=${rawTools.length}`,
-    outputSummary: summarizeToolNames(tools),
+    outputSummary: `${summarizeToolNames(tools)} (defaultSet=${defaultToolSet}; available=${allTools.length})`,
     toolCount: tools.length,
-    policyDecisions: rawTools.length === tools.length ? ["allow:default"] : [`filtered:${rawTools.length - tools.length}`]
+    policyDecisions: rawTools.length === allTools.length ? ["allow:default"] : [`filtered:${rawTools.length - allTools.length}`]
   });
   for (const diag of diagnostics.filter((d) => d.type === "collision")) {
     console.log(`[CLI] ${diag.message}`);
@@ -69698,6 +69759,7 @@ async function composeCliRuntime(params) {
     skillsSection,
     knowledgeSection,
     tools,
+    allTools,
     fileObservationState,
     extensionPaths: params.extensionPaths,
     extensionFlags: params.extensionFlags ?? {},
@@ -69707,6 +69769,7 @@ async function composeCliRuntime(params) {
         model,
         apiKey,
         tools,
+        allTools,
         fileObservationState,
         sessionManager,
         skills,
@@ -69747,11 +69810,13 @@ async function loadPrintModeExtensions(params) {
   const executionState = new ExecutionStateManager();
   const activeSession = params.sessionManager.getActiveSession();
   executionState.restoreFromMetadata(activeSession?.metadata?.executionState);
+  let availableTools = [...params.allTools ?? []];
   const actions = {
     setActiveTools: (toolNames) => {
       const agent = params.getAgent();
       if (!agent) return;
-      const nextTools = agent.state.tools.filter((tool) => toolNames.includes(tool.name));
+      const toolList = availableTools.length ? availableTools : agent.state.tools;
+      const nextTools = toolList.filter((tool) => toolNames.includes(tool.name));
       agent.state.tools = nextTools;
     },
     getActiveTools: () => params.getAgent()?.state.tools.map((tool) => tool.name) ?? [],
@@ -69781,11 +69846,11 @@ async function loadPrintModeExtensions(params) {
     apiKey: params.apiKey,
     model: params.model,
     skills: params.skills,
-    getAllTools: () => params.getAgent()?.state.tools.map((tool) => ({
+    getAllTools: () => (availableTools.length ? availableTools : params.getAgent()?.state.tools ?? []).map((tool) => ({
       name: tool.name,
       description: tool.description,
       parameters: tool.parameters
-    })) ?? [],
+    })),
     getRuntimeTools: () => params.getAgent()?.state.tools ?? [],
     resolveModelClass: (modelClass) => params.modelRegistry.resolveModelClass(modelClass),
     getMessages: () => params.getAgent()?.state.messages ?? [],
@@ -69818,10 +69883,12 @@ async function loadPrintModeExtensions(params) {
     false
   );
   runner.setUIContext(uiContext);
+  const extensionTools = convertExtensionTools(extensions);
+  availableTools = [...availableTools, ...extensionTools];
   return {
     extensions,
     runner,
-    extensionTools: convertExtensionTools(extensions)
+    extensionTools
   };
 }
 async function runPrintMode(params) {
@@ -69853,7 +69920,8 @@ async function runPrintMode(params) {
     skills: runtime.skills,
     getAgent: () => agent,
     sessionManager: runtime.sessionManager,
-    settingsManager: runtime.settingsManager
+    settingsManager: runtime.settingsManager,
+    allTools: runtime.allTools
   });
   const printModeTools = [...runtime.tools, ...printModeExtensions.extensionTools];
   recordCliCompositionStep(runtime.compositionTrace, {
@@ -70145,11 +70213,13 @@ async function loadJsonModeExtensions(params) {
   const executionState = new ExecutionStateManager();
   const activeSession = params.runtime.sessionManager.getActiveSession();
   executionState.restoreFromMetadata(activeSession?.metadata?.executionState);
+  let availableTools = [...params.runtime.allTools];
   const actions = {
     setActiveTools: (toolNames) => {
       const agent = params.getAgent();
       if (!agent) return;
-      agent.state.tools = agent.state.tools.filter((tool) => toolNames.includes(tool.name));
+      const toolList = availableTools.length > 0 ? availableTools : agent.state.tools;
+      agent.state.tools = toolList.filter((tool) => toolNames.includes(tool.name));
     },
     getActiveTools: () => params.getAgent()?.state.tools.map((tool) => tool.name) ?? [],
     sendUserMessage: () => {
@@ -70182,11 +70252,11 @@ async function loadJsonModeExtensions(params) {
       return params.runtime.model;
     },
     skills: params.runtime.skills,
-    getAllTools: () => params.getAgent()?.state.tools.map((tool) => ({
+    getAllTools: () => (availableTools.length > 0 ? availableTools : params.getAgent()?.state.tools ?? []).map((tool) => ({
       name: tool.name,
       description: tool.description,
       parameters: tool.parameters
-    })) ?? [],
+    })),
     getRuntimeTools: () => params.getAgent()?.state.tools ?? [],
     resolveModelClass: (modelClass) => params.runtime.modelRegistry.resolveModelClass(modelClass),
     getMessages: () => params.getAgent()?.state.messages ?? [],
@@ -70219,9 +70289,11 @@ async function loadJsonModeExtensions(params) {
     false
   );
   runner.setUIContext(uiContext);
+  const extensionTools = convertExtensionTools(extensions);
+  availableTools = [...availableTools, ...extensionTools];
   return {
     runner,
-    extensionTools: convertExtensionTools(extensions),
+    extensionTools,
     extensionCount: extensions.length
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cydm/pie",
-	"version": "1.0.26",
+	"version": "1.0.27",
 	"description": "Pie AI Agent CLI",
 	"type": "module",
 	"bin": {