@polka-codes/core 0.8.1 → 0.8.2

package/dist/index.js

@@ -905,6 +905,7 @@ __export(allTools_exports, {
   renameFile: () => renameFile_default,
   replaceInFile: () => replaceInFile_default,
   searchFiles: () => searchFiles_default,
+  updateKnowledge: () => updateKnowledge_default,
   writeToFile: () => writeToFile_default
 });
 
@@ -1471,11 +1472,15 @@ var handler7 = async (provider, args) => {
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path);
-    const isEmpty = fileContent.trim().length === 0;
-    if (isEmpty) {
-      resp.push(`<read_file_file_content path="${path}" is_empty="true" />`);
+    if (!fileContent) {
+      resp.push(`<read_file_file_content path="${path}" file_not_found="true" />`);
     } else {
-      resp.push(`<read_file_file_conten path="${path}">${fileContent}</read_file_file_content>`);
+      const isEmpty = fileContent.trim().length === 0;
+      if (isEmpty) {
+        resp.push(`<read_file_file_content path="${path}" is_empty="true" />`);
+      } else {
+        resp.push(`<read_file_file_conten path="${path}">${fileContent}</read_file_file_content>`);
+      }
     }
   }
   return {
@@ -1588,6 +1593,12 @@ var handler8 = async (provider, args) => {
   const path = getString(args, "path");
   const diff = getString(args, "diff");
   const fileContent = await provider.readFile(path);
+  if (fileContent == null) {
+    return {
+      type: "Error" /* Error */,
+      message: `<error><replace_in_file_path>${path}</replace_in_file_path><error_message>File not found</error_message></error>`
+    };
+  }
   const result = await replaceInFile(fileContent, diff);
   await provider.writeFile(path, result);
   return {
@@ -1680,10 +1691,268 @@ var searchFiles_default = {
   isAvailable: isAvailable9
 };
 
-// src/tools/writeToFile.ts
+// src/tools/updateKnowledge.ts
+import { join } from "node:path";
+import YAML from "yaml";
 var toolInfo10 = {
+  name: "update_knowledge",
+  description: "Update knowledge in a knowledge.ai.yml file with smart merging capabilities. This tool lets you add, update, or remove information using path-based updates and special directives.",
+  parameters: [
+    {
+      name: "path",
+      description: "Directory containing (or where to create) the knowledge.ai.yml file",
+      required: true,
+      usageValue: "Directory path here"
+    },
+    {
+      name: "knowledge",
+      description: "YAML content to merge into the knowledge file",
+      required: true,
+      usageValue: "YAML content with knowledge to update"
+    }
+  ],
+  examples: [
+    {
+      description: "Add a new file entry",
+      parameters: [
+        { name: "path", value: "src/utils" },
+        {
+          name: "knowledge",
+          value: `files:
+  "newFile.ts":
+    description: "A new utility file"
+    api:
+      functions:
+        1:
+          name: "processData"
+          params:
+            1: { name: "data", type: "object" }
+          returns: "object"`
+        }
+      ]
+    },
+    {
+      description: "Update an existing file description",
+      parameters: [
+        { name: "path", value: "src/utils" },
+        {
+          name: "knowledge",
+          value: `files:
+  "existingFile.ts":
+    description: "Updated description for the file"`
+        }
+      ]
+    },
+    {
+      description: "Add a new rule",
+      parameters: [
+        { name: "path", value: "src" },
+        {
+          name: "knowledge",
+          value: `rules:
+    10: "New rule to follow"`
+        }
+      ]
+    },
+    {
+      description: "Remove a rule",
+      parameters: [
+        { name: "path", value: "src" },
+        {
+          name: "knowledge",
+          value: `rules:
+    5: null`
+        }
+      ]
+    },
+    {
+      description: "Update nested properties using dot notation",
+      parameters: [
+        { name: "path", value: "src/components" },
+        {
+          name: "knowledge",
+          value: `files.Button.tsx.api.functions.1.description: "Updated function description"`
+        }
+      ]
+    }
+  ],
+  permissionLevel: 2 /* Write */
+};
+function getNextKey(obj) {
+  if (!obj || typeof obj !== "object") return 1;
+  const numericKeys = Object.keys(obj).filter((key) => !Number.isNaN(Number(key))).map((key) => Number(key));
+  if (numericKeys.length === 0) return 1;
+  return Math.max(...numericKeys) + 1;
+}
+function arrayToNumberedDict(arr) {
+  const result = {};
+  arr.forEach((item, index) => {
+    result[(index + 1).toString()] = item;
+  });
+  return result;
+}
+function deepMerge(target, source) {
+  if (source && typeof source === "object") {
+    if (Array.isArray(target)) {
+      target = arrayToNumberedDict(target);
+    }
+    if (Array.isArray(source)) {
+      source = arrayToNumberedDict(source);
+    }
+    if (typeof target === "object" && !Array.isArray(target) && "$merge" in source) {
+      const result = { ...target };
+      const itemsToMerge = Array.isArray(source.$merge) ? source.$merge : [source.$merge];
+      for (const item of itemsToMerge) {
+        if (typeof item === "object" && item !== null && "path" in item) {
+          let found = false;
+          for (const key in result) {
+            if (typeof result[key] === "object" && result[key] !== null && "path" in result[key] && result[key].path === item.path) {
+              result[key] = deepMerge(result[key], item);
+              found = true;
+              break;
+            }
+          }
+          if (!found) {
+            const nextKey = getNextKey(result).toString();
+            result[nextKey] = item;
+          }
+        } else {
+          const nextKey = getNextKey(result).toString();
+          result[nextKey] = item;
+        }
+      }
+      return result;
+    }
+    if (typeof target === "object" && !Array.isArray(target) && "$remove" in source) {
+      const result = { ...target };
+      const itemsToRemove = Array.isArray(source.$remove) ? source.$remove : [source.$remove];
+      for (const item of itemsToRemove) {
+        if (typeof item === "string" && !Number.isNaN(Number(item))) {
+          delete result[item];
+        } else if (typeof item === "object" && item !== null && "path" in item) {
+          for (const key in result) {
+            if (typeof result[key] === "object" && result[key] !== null && "path" in result[key] && result[key].path === item.path) {
+              delete result[key];
+              break;
+            }
+          }
+        } else {
+          for (const key in result) {
+            if (result[key] === item) {
+              delete result[key];
+              break;
+            }
+          }
+        }
+      }
+      return result;
+    }
+    if (typeof target === "object" && !Array.isArray(target) && "$replace" in source) {
+      const replacements = Array.isArray(source.$replace) ? source.$replace : [source.$replace];
+      return arrayToNumberedDict(replacements);
+    }
+  }
+  if (!source || typeof source !== "object") {
+    return source;
+  }
+  if (!target || typeof target !== "object") {
+    if (Array.isArray(source)) {
+      return arrayToNumberedDict(source);
+    }
+    return { ...source };
+  }
+  const output = { ...target };
+  for (const key in source) {
+    if (key.startsWith("$")) continue;
+    output[key] = deepMerge(target[key], source[key]);
+  }
+  return output;
+}
+var handler10 = async (provider, args) => {
+  if (!provider.readFile || !provider.writeFile) {
+    return {
+      type: "Error" /* Error */,
+      message: "File operations not available. Cannot update knowledge file."
+    };
+  }
+  const dirPath = getString(args, "path");
+  const knowledgeContent = getString(args, "knowledge");
+  const filePath = join(dirPath, "knowledge.ai.yml");
+  try {
+    let newKnowledge;
+    try {
+      newKnowledge = YAML.parse(knowledgeContent);
+    } catch (error) {
+      return {
+        type: "Error" /* Error */,
+        message: `Invalid YAML content: ${error.message}`
+      };
+    }
+    const dotNotationUpdates = {};
+    const regularUpdates = {};
+    for (const key in newKnowledge) {
+      if (key.includes(".")) {
+        dotNotationUpdates[key] = newKnowledge[key];
+      } else {
+        regularUpdates[key] = newKnowledge[key];
+      }
+    }
+    const existingContent = await provider.readFile(filePath);
+    let existingKnowledge = {};
+    if (existingContent) {
+      try {
+        existingKnowledge = YAML.parse(existingContent);
+      } catch (error) {
+        return {
+          type: "Error" /* Error */,
+          message: `Error parsing existing knowledge file: ${error.message}`
+        };
+      }
+    }
+    let updatedKnowledge = existingKnowledge;
+    updatedKnowledge = deepMerge(updatedKnowledge, regularUpdates);
+    if (Object.keys(dotNotationUpdates).length > 0) {
+      const nestedUpdates = {};
+      for (const path in dotNotationUpdates) {
+        const parts = path.split(".");
+        let current = nestedUpdates;
+        for (let i = 0; i < parts.length - 1; i++) {
+          const part = parts[i];
+          if (!(part in current)) {
+            current[part] = {};
+          }
+          current = current[part];
+        }
+        current[parts[parts.length - 1]] = dotNotationUpdates[path];
+      }
+      updatedKnowledge = deepMerge(updatedKnowledge, nestedUpdates);
+    }
+    const updatedContent = YAML.stringify(updatedKnowledge);
+    await provider.writeFile(filePath, updatedContent);
+    return {
+      type: "Reply" /* Reply */,
+      message: `<update_knowledge_path>${filePath}</update_knowledge_path><status>Success</status>`
+    };
+  } catch (error) {
+    return {
+      type: "Error" /* Error */,
+      message: `Error updating knowledge file: ${error.message}`
+    };
+  }
+};
+var isAvailable10 = (provider) => {
+  return !!provider.readFile && !!provider.writeFile;
+};
+var updateKnowledge_default = {
+  ...toolInfo10,
+  handler: handler10,
+  isAvailable: isAvailable10
+};
+
+// src/tools/writeToFile.ts
+var toolInfo11 = {
   name: "write_to_file",
-  description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.",
+  description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;` and `&gt;`.",
   parameters: [
     {
       name: "path",
@@ -1726,7 +1995,7 @@ export default App;
   ],
   permissionLevel: 2 /* Write */
 };
-var handler10 = async (provider, args) => {
+var handler11 = async (provider, args) => {
   if (!provider.writeFile) {
     return {
       type: "Error" /* Error */,
@@ -1741,17 +2010,17 @@ var handler10 = async (provider, args) => {
     message: `<write_to_file_path>${path}</write_to_file_path><status>Success</status>`
   };
 };
-var isAvailable10 = (provider) => {
+var isAvailable11 = (provider) => {
   return !!provider.writeFile;
 };
 var writeToFile_default = {
-  ...toolInfo10,
-  handler: handler10,
-  isAvailable: isAvailable10
+  ...toolInfo11,
+  handler: handler11,
+  isAvailable: isAvailable11
 };
 
 // src/tools/handOver.ts
-var toolInfo11 = {
+var toolInfo12 = {
   name: "hand_over",
   description: "Hand over the current task to another agent to complete. This tool MUST NOT to be used with any other tool.",
   parameters: [
@@ -1805,7 +2074,7 @@ var toolInfo11 = {
   ],
   permissionLevel: 0 /* None */
 };
-var handler11 = async (_provider, args) => {
+var handler12 = async (_provider, args) => {
   const agentName = getString(args, "agent_name");
   const task = getString(args, "task");
   const context = getString(args, "context", void 0);
@@ -1819,17 +2088,17 @@ var handler11 = async (_provider, args) => {
     // originalTask will be set by AgentBase
   };
 };
-var isAvailable11 = (_provider) => {
+var isAvailable12 = (_provider) => {
   return true;
 };
 var handOver_default = {
-  ...toolInfo11,
-  handler: handler11,
-  isAvailable: isAvailable11
+  ...toolInfo12,
+  handler: handler12,
+  isAvailable: isAvailable12
 };
 
 // src/tools/removeFile.ts
-var toolInfo12 = {
+var toolInfo13 = {
   name: "remove_file",
   description: "Request to remove a file at the specified path.",
   parameters: [
@@ -1853,7 +2122,7 @@ var toolInfo12 = {
   ],
   permissionLevel: 2 /* Write */
 };
-var handler12 = async (provider, args) => {
+var handler13 = async (provider, args) => {
   if (!provider.removeFile) {
     return {
       type: "Error" /* Error */,
@@ -1867,17 +2136,17 @@ var handler12 = async (provider, args) => {
     message: `<remove_file_path>${path}</remove_file_path><status>Success</status>`
   };
 };
-var isAvailable12 = (provider) => {
+var isAvailable13 = (provider) => {
   return !!provider.removeFile;
 };
 var removeFile_default = {
-  ...toolInfo12,
-  handler: handler12,
-  isAvailable: isAvailable12
+  ...toolInfo13,
+  handler: handler13,
+  isAvailable: isAvailable13
 };
 
 // src/tools/renameFile.ts
-var toolInfo13 = {
+var toolInfo14 = {
   name: "rename_file",
   description: "Request to rename a file from source path to target path.",
   parameters: [
@@ -1911,7 +2180,7 @@ var toolInfo13 = {
   ],
   permissionLevel: 2 /* Write */
 };
-var handler13 = async (provider, args) => {
+var handler14 = async (provider, args) => {
   if (!provider.renameFile) {
     return {
       type: "Error" /* Error */,
@@ -1926,13 +2195,13 @@ var handler13 = async (provider, args) => {
     message: `<rename_file_path>${targetPath}</rename_file_path><status>Success</status>`
   };
 };
-var isAvailable13 = (provider) => {
+var isAvailable14 = (provider) => {
   return !!provider.renameFile;
 };
 var renameFile_default = {
-  ...toolInfo13,
-  handler: handler13,
-  isAvailable: isAvailable13
+  ...toolInfo14,
+  handler: handler14,
+  isAvailable: isAvailable14
 };
 
 // src/getAvailableTools.ts
@@ -2213,6 +2482,7 @@ var AgentBase = class {
   handlers;
   #messages = [];
   #originalTask;
+  #policies;
   constructor(name, ai, config) {
     this.ai = ai;
     if (config.agents && config.agents.length > 0) {
@@ -2220,12 +2490,29 @@ var AgentBase = class {
       config.systemPrompt += `
 ${agents}`;
     }
-    this.config = config;
     const handlers = {};
     for (const tool of config.tools) {
       handlers[tool.name] = tool;
     }
+    const policies = [];
+    for (const policy of config.policies) {
+      const instance = policy(handlers);
+      if (instance) {
+        policies.push(instance);
+        if (instance.prompt) {
+          config.systemPrompt += `
+${instance.prompt}`;
+        }
+        if (instance.tools) {
+          for (const tool of instance.tools) {
+            handlers[tool.name] = tool;
+          }
+        }
+      }
+    }
     this.handlers = handlers;
+    this.config = config;
+    this.#policies = policies;
   }
   get messages() {
     return this.#messages;
@@ -2236,16 +2523,16 @@ ${agents}`;
   async #callback(event) {
     await this.config.callback?.(event);
   }
-  async start(prompt5) {
-    this.#originalTask = prompt5;
+  async start(prompt6) {
+    this.#originalTask = prompt6;
     this.#callback({ kind: "StartTask" /* StartTask */, agent: this, systemPrompt: this.config.systemPrompt });
-    return await this.#processLoop(prompt5);
+    return await this.#processLoop(prompt6);
   }
-  async step(prompt5) {
+  async step(prompt6) {
     if (this.#messages.length === 0) {
       this.#callback({ kind: "StartTask" /* StartTask */, agent: this, systemPrompt: this.config.systemPrompt });
     }
-    return await this.#request(prompt5);
+    return await this.#request(prompt6);
   }
   async handleStepResponse(response) {
     return this.#handleResponse(response);
@@ -2318,9 +2605,15 @@ ${agents}`;
     return ret;
   }
   async #handleResponse(response) {
-    const toolReponses = [];
+    const toolResponses = [];
     let hasPause = false;
-    outer: for (const content of response) {
+    let updatedResponse = response;
+    for (const hook of this.#policies) {
+      if (hook.updateResponse) {
+        updatedResponse = await hook.updateResponse(updatedResponse);
+      }
+    }
+    outer: for (const content of updatedResponse) {
       switch (content.type) {
         case "text":
           break;
@@ -2330,26 +2623,26 @@ ${agents}`;
           switch (toolResp.type) {
             case "Reply" /* Reply */:
               await this.#callback({ kind: "ToolReply" /* ToolReply */, agent: this, tool: content.name });
-              toolReponses.push({ type: "response", tool: content.name, response: toolResp.message });
+              toolResponses.push({ type: "response", tool: content.name, response: toolResp.message });
               break;
             case "Exit" /* Exit */:
-              if (toolReponses.length > 0) {
+              if (toolResponses.length > 0) {
                 break outer;
               }
               return { type: "exit", reason: toolResp };
             case "Invalid" /* Invalid */:
               await this.#callback({ kind: "ToolInvalid" /* ToolInvalid */, agent: this, tool: content.name });
-              toolReponses.push({ type: "response", tool: content.name, response: toolResp.message });
+              toolResponses.push({ type: "response", tool: content.name, response: toolResp.message });
               break outer;
             case "Error" /* Error */:
               await this.#callback({ kind: "ToolError" /* ToolError */, agent: this, tool: content.name });
-              toolReponses.push({ type: "response", tool: content.name, response: toolResp.message });
+              toolResponses.push({ type: "response", tool: content.name, response: toolResp.message });
               break outer;
             case "Interrupted" /* Interrupted */:
               await this.#callback({ kind: "ToolInterrupted" /* ToolInterrupted */, agent: this, tool: content.name });
               return { type: "exit", reason: toolResp };
             case "HandOver" /* HandOver */: {
-              if (toolReponses.length > 0) {
+              if (toolResponses.length > 0) {
                 break outer;
               }
               const handOverResp = {
@@ -2369,7 +2662,7 @@ ${agents}`;
               return { type: "exit", reason: handOverResp };
             }
             case "Delegate" /* Delegate */: {
-              if (toolReponses.length > 0) {
+              if (toolResponses.length > 0) {
                 continue;
               }
               const delegateResp = {
@@ -2390,7 +2683,7 @@ ${agents}`;
             }
             case "Pause" /* Pause */: {
               await this.#callback({ kind: "ToolPause" /* ToolPause */, agent: this, tool: content.name, object: toolResp.object });
-              toolReponses.push({ type: "pause", tool: content.name, object: toolResp.object });
+              toolResponses.push({ type: "pause", tool: content.name, object: toolResp.object });
               hasPause = true;
             }
           }
@@ -2399,29 +2692,37 @@ ${agents}`;
       }
     }
     if (hasPause) {
-      return { type: "exit", reason: { type: "Pause", responses: toolReponses } };
+      return { type: "exit", reason: { type: "Pause", responses: toolResponses } };
     }
-    if (toolReponses.length === 0) {
+    if (toolResponses.length === 0) {
       return { type: "reply", message: responsePrompts.requireUseTool };
     }
-    const finalResp = toolReponses.filter((resp) => resp.type === "response").map(({ tool, response: response2 }) => responsePrompts.toolResults(tool, response2)).join("\n\n");
+    const finalResp = toolResponses.filter((resp) => resp.type === "response").map(({ tool, response: response2 }) => responsePrompts.toolResults(tool, response2)).join("\n\n");
     return { type: "reply", message: finalResp };
   }
   async #invokeTool(name, args) {
     try {
-      const handler14 = this.handlers[name]?.handler;
-      if (!handler14) {
+      const handler15 = this.handlers[name]?.handler;
+      if (!handler15) {
         return {
           type: "Error" /* Error */,
           message: responsePrompts.errorInvokeTool(name, "Tool not found"),
           canRetry: false
         };
       }
+      for (const instance of this.#policies) {
+        if (instance.onBeforeInvokeTool) {
+          const resp2 = await instance.onBeforeInvokeTool(name, args);
+          if (resp2) {
+            return resp2;
+          }
+        }
+      }
       const resp = await this.onBeforeInvokeTool(this.handlers[name].name, args);
       if (resp) {
         return resp;
       }
-      return await handler14(this.config.provider, args);
+      return await handler15(this.config.provider, args);
     } catch (error) {
       return {
         type: "Error" /* Error */,
@@ -2496,7 +2797,8 @@ var AnalyzerAgent = class extends AgentBase {
       interactive: options.interactive,
       agents: options.agents,
       scripts: options.scripts,
-      callback: options.callback
+      callback: options.callback,
+      policies: options.policies
     });
   }
   onBeforeInvokeTool() {
@@ -2520,47 +2822,43 @@ var fullSystemPrompt2 = (info, tools, toolNamePrefix, instructions, scripts) =>
 
 ## Role
 You are the **Architect** agent, responsible for:
-1. **Task Analysis** \u2013 Understand requirements.
-2. **File Identification** \u2013 Find and select relevant files.
-3. **File Reading** \u2013 Use the provided tools to gather information from these files.
-4. **Implementation Plan** \u2013 Draft a concise plan detailing steps, resources, and dependencies.
-5. **Review & Improve** \u2013 Evaluate and refine the plan.
-6. **Handover/Delegate** \u2013 Provide the final plan, context, and files to the **Coder** agent.
+1. **Task Analysis** - Understand requirements.
+2. **File Identification** - Find and select relevant files.
+3. **File Reading** - Use the provided tools to gather information from these files.
+4. **Implementation Plan** - Draft a detailed, unambiguous, *code-free* plan (pseudocode or interface stubs allowed).
+5. **Review & Improve** - Evaluate and refine the plan.
+6. **Handover/Delegate** - Provide the final plan, context, and files to the **Coder** agent.
 
-> **Note**: The **Architect** agent must not make any direct modifications. Your role is limited to creating the implementation plan and handing it over to the **Coder** agent, who will perform any actual changes.
+> **Note**: The **Architect** agent must **never** modify project files directly. Your sole deliverable is the implementation plan; the **Coder** agent will perform all code changes.
 
 ## Rules
-1. **Consistency**: Maintain alignment with the user\u2019s instructions and the system\u2019s objectives at all times.
-2. **Relevance**: Only read and use files directly related to the task. Avoid unnecessary or tangential information.
-3. **Conciseness**: Keep all communications and plans succinct, avoiding superfluous or repetitive details.
-4. **Accuracy**: Ensure the information you gather and any conclusions you draw are correct and verifiable.
-5. **Clarity**: Present the final plan and any supporting details in a structured and easily understandable format.
-6. **Minimal Queries**: Ask clarifying questions only when essential, and avoid repeated questioning that does not add value.
+1. **Consistency** - Always align with the user's instructions and project objectives.
+2. **Relevance** - Consult only files essential to the task.
+3. **Conciseness** - Communicate succinctly; avoid repetition.
+4. **Accuracy** - Ensure findings and conclusions are correct and verifiable.
+5. **Clarity** - Present information in a structured, easy-to-follow format.
+6. **Minimal Queries** - Ask clarifying questions only when essential; avoid redundant questioning.
 
 ## Steps
 1. **Analyze Task**
-   - Gather and understand the user\u2019s requirements.
-   - Note any potential constraints or objectives that may influence the plan.
+   - Capture requirements, constraints, and objectives.
 
 2. **Identify Relevant Files**
-   - Determine which files or documents are necessary.
-   - Justify why these files are relevant.
+   - List the specific files needed and justify each selection.
 
 3. **Read Files via Tools**
-   - Utilize the provided tools to access and extract information from the identified files.
-   - Summarize key insights or data for the solution.
+   - Extract key information with provided tools and summarize insights.
 
 4. **Create Implementation Plan**
-   - Outline tasks, define milestones, and detail resources or dependencies.
-   - Provide clear, concise instructions for each step.
-   - Each step should be appropriate sized and self-contained.
+   - Produce a **detailed, step-by-step plan** that:
+     - Describes tasks, resources, and dependencies.
+     - Uses pseudocode or interface declarations *only*\u2014no concrete code.
+     - Is explicit enough for the **Coder** agent to implement without further clarification.
 
 5. **Handover/Delegate**
-   - Evaluate the number of steps required.
-   - Handleover to the **Coder** agent if only one step is required.
-   - If multiple steps are required, delegate each step to the **Coder** agent.
-   - Deliver the final implementation plan, context, and relevant files to the **Coder** agent.
-   - Provide any additional instructions or clarifications needed for successful implementation.
+   - If the plan consists of a single self-contained step, hand it over as one task.
+   - If multiple steps are required, break them into numbered tasks for the **Coder** agent.
+   - Provide all necessary context, file references, and clarifications for successful execution.
 
 ${toolUsePrompt(tools, toolNamePrefix)}
 ${capabilities(toolNamePrefix)}
@@ -2598,7 +2896,8 @@ var ArchitectAgent = class extends AgentBase {
       interactive: options.interactive,
       agents: options.agents,
       scripts: options.scripts,
-      callback: options.callback
+      callback: options.callback,
+      policies: options.policies
     });
   }
   onBeforeInvokeTool() {
@@ -2723,7 +3022,8 @@ var CodeFixerAgent = class extends AgentBase {
       interactive: options.interactive,
       agents: options.agents,
       scripts: options.scripts,
-      callback: options.callback
+      callback: options.callback,
+      policies: options.policies
     });
     this.#maxRetries = options.maxRetries ?? 5;
   }
@@ -2924,7 +3224,8 @@ var CoderAgent = class extends AgentBase {
       interactive: options.interactive,
       agents: options.agents,
       scripts: options.scripts,
-      callback: options.callback
+      callback: options.callback,
+      policies: options.policies
     });
   }
   async onBeforeInvokeTool(name, args) {
@@ -2997,24 +3298,24 @@ var MultiAgent = class {
     switch (exitReason.type) {
       case "HandOver" /* HandOver */: {
         this.#agents.pop();
-        const prompt5 = await this.#config.getPrompt?.(
+        const prompt6 = await this.#config.getPrompt?.(
           exitReason.agentName,
           exitReason.task,
           exitReason.context,
           exitReason.files,
           exitReason.originalTask
         ) ?? exitReason.task;
-        return await this.#startTask(exitReason.agentName, prompt5);
+        return await this.#startTask(exitReason.agentName, prompt6);
       }
       case "Delegate" /* Delegate */: {
-        const prompt5 = await this.#config.getPrompt?.(
+        const prompt6 = await this.#config.getPrompt?.(
           exitReason.agentName,
           exitReason.task,
           exitReason.context,
           exitReason.files,
           exitReason.originalTask
         ) ?? exitReason.task;
-        const delegateResult = await this.#startTask(exitReason.agentName, prompt5);
+        const delegateResult = await this.#startTask(exitReason.agentName, prompt6);
         switch (delegateResult.type) {
           case "HandOver" /* HandOver */:
           case "Delegate" /* Delegate */:
@@ -3059,11 +3360,222 @@ var MultiAgent = class {
   }
 };
 
+// src/Agent/policies/KnowledgeManagement.ts
+import { dirname, join as join2 } from "node:path";
+
+// src/config.ts
+import { z } from "zod";
+var providerModelSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  parameters: z.record(z.string(), z.any()).optional()
+});
+var agentSchema = providerModelSchema.extend({
+  initialContext: z.object({
+    maxFileCount: z.number().int().positive().optional(),
+    excludes: z.array(z.string()).optional()
+  }).optional()
+});
+var configSchema = z.object({
+  agent: z.string().optional(),
+  prices: z.record(
+    z.string(),
+    // provider
+    z.record(
+      z.string(),
+      // model
+      z.object({
+        inputPrice: z.number().optional(),
+        outputPrice: z.number().optional(),
+        cacheWritesPrice: z.number().optional(),
+        cacheReadsPrice: z.number().optional()
+      })
+    )
+  ).optional(),
+  providers: z.record(
+    z.string(),
+    z.object({
+      apiKey: z.string().optional(),
+      defaultModel: z.string().optional(),
+      defaultParameters: z.record(z.string(), z.any()).optional()
+    })
+  ).optional(),
+  defaultProvider: z.string().optional(),
+  defaultModel: z.string().optional(),
+  defaultParameters: z.record(z.string(), z.any()).optional(),
+  maxMessageCount: z.number().int().positive().optional(),
+  budget: z.number().positive().optional(),
+  scripts: z.record(
+    z.string(),
+    z.string().or(
+      z.object({
+        command: z.string(),
+        description: z.string()
+      })
+    )
+  ).optional(),
+  agents: z.record(z.string(), agentSchema).optional(),
+  commands: z.object({
+    default: providerModelSchema.optional()
+  }).catchall(providerModelSchema).optional(),
+  rules: z.array(z.string()).optional().or(z.string()).optional(),
+  excludeFiles: z.array(z.string()).optional(),
+  policies: z.array(z.string()).optional()
+}).strict();
+var Policies = /* @__PURE__ */ ((Policies2) => {
+  Policies2["KnowledgeManagement"] = "knowledgemanagement";
+  return Policies2;
+})(Policies || {});
+
+// src/Agent/policies/KnowledgeManagement.ts
+var prompt = `
+====
+
+# Knowledge Extraction & Maintenance
+
+You are equipped with **Knowledge Management** capabilities:
+
+1. **What to capture**
+   \u2022 Public API of each file (public classes, functions, methods, parameters, return types).
+   \u2022 High-level description of each file's purpose.
+   \u2022 Invariants and assumptions that must always hold.
+   \u2022 Project or directory-specific coding patterns, styles, and architectural conventions.
+   \u2022 Rules (commenting, testing, documentation, security, etc.).
+   \u2022 Any other insight that a future contributor would find crucial.
+
+2. **Where to store it**
+   \u2022 Save knowledge in a YAML file named \`knowledge.ai.yml\`.
+   \u2022 **Create the file in the repository root if it does not yet exist.**
+   \u2022 One file per directory.
+     - The repository root file records knowledge that applies project-wide (e.g., service responsibilities, global patterns).
+     - Each sub-directory keeps only the knowledge relevant to that directory or package.
+   \u2022 Use clear top-level keys such as \`description\`, \`files\`, \`rules\`.
+
+3. **When to update**
+   \u2022 **Default behaviour:** only create / update knowledge for the files you actively read, create, or modify during the current task.
+     - Operate on other files **only if the user explicitly requests it**.
+   \u2022 **While working**: after reading, analysing, creating, or modifying code, immediately record any new or changed knowledge.
+   \u2022 **On refactor / deletion**: locate and delete or amend obsolete entries so that knowledge never drifts from the codebase.
+   \u2022 **Granularity**: update only the affected directory's \`knowledge.ai.yml\`, except when the change has global impact.
+
+4. **How to format (illustrative)**
+\`\`\`yaml
+description: "description of the directory"
+files:
+  "math.ts":
+    description: "Numeric helpers for currency calculations"
+    api:
+      functions:
+        1:
+          name: "add"
+          params:
+            1: { name: "a", type: "number" }
+            2: { name: "b", type: "number" }
+          returns: "number"
+rules:
+  1: "rules that apply to all files in this directory"
+\`\`\`
+
+5. **Source of truth**
+   \u2022 **Never invent knowledge.** Everything you record must be *directly derived* from existing code, comments, commit messages, or explicit user instructions.
+   \u2022 If a section has no confirmed content, omit it rather than guessing.
+
+6. **Automatic context**
+   When you are asked to read or modify a file, the orchestration layer will supply any existing knowledge for that path automatically. Use it, refine it, and keep it accurate.
+
+7. **Using the updateKnowledge tool**
+   You can use the \`updateKnowledge\` tool to efficiently update knowledge files with smart merging capabilities.
+
+8. **Dictionary-First Format**
+   \u2022 **Always prefer dictionaries** for structured data.
+   \u2022 The **\`files\` section must be a dictionary keyed by file path** (e.g., \`"math.ts": {...}\`).
+   \u2022 For other lists (rules, functions, etc.), use numbered dictionaries.
+   \u2022 Arrays are allowed only when strict ordering is essential and dictionaries cannot express it.
+   \u2022 When removing items, refer to them by their numeric key or index; gaps are fine.
+
+Your workflow **must**:
+   1. Detect knowledge deltas.
+   2. Create \`knowledge.ai.yml\` if missing and write edits to the correct file.
+   3. Remove stale facts.
+   4. Use provided tools to update the knowledge files.
+   5. Record only evidence-based information; do not hallucinate.
+   6. Use dictionaries throughout, with numbered dictionaries for ordered data and path-keyed dictionaries for the \`files\` section.
+`;
+var KnowledgeManagementPolicy = (tools) => {
+  if (!tools[readFile_default.name]) {
+    return void 0;
+  }
+  const readFiles = /* @__PURE__ */ new Set();
+  return {
+    name: "knowledgemanagement" /* KnowledgeManagement */,
+    tools: tools[writeToFile_default.name] ? [tools[updateKnowledge_default.name]] : [],
+    prompt: tools[writeToFile_default.name] || tools[updateKnowledge_default.name] ? prompt : void 0,
+    async getKnowledgeFilePaths(inputFiles) {
+      const paths = /* @__PURE__ */ new Set();
+      for (const file of inputFiles) {
+        let dir = dirname(file);
+        paths.add(dir);
+        while (dir !== ".") {
+          paths.add(dir);
+          dir = dirname(dir);
+        }
+      }
+      const allFullPaths = [];
+      for (const path of paths) {
+        if (path === ".") {
+          continue;
+        }
+        const fullpath = join2(path, "knowledge.ai.yml");
+        if (!readFiles.has(fullpath)) {
+          allFullPaths.push(fullpath);
+          readFiles.add(fullpath);
+        }
+      }
+      return allFullPaths;
+    },
+    async updateResponse(response) {
+      const files = /* @__PURE__ */ new Set();
+      for (const content of response) {
+        if (content.type === "tool_use") {
+          switch (content.name) {
+            case readFile_default.name: {
+              const paths = getStringArray(content.params, "path");
+              for (const path of paths) {
+                files.add(path);
+              }
+              break;
+            }
+            case listFiles_default.name: {
+              const path = getString(content.params, "path");
+              files.add(path);
+              break;
+            }
+          }
+        }
+      }
+      const allFullPaths = await this.getKnowledgeFilePaths(Array.from(files));
+      if (allFullPaths.length === 0) {
+        return response;
+      }
+      return [
+        ...response,
+        {
+          type: "tool_use",
+          name: readFile_default.name,
+          params: {
+            path: allFullPaths.join(",")
+          }
+        }
+      ];
+    }
+  };
+};
+
 // src/Agent/index.ts
 var allAgents = [architectAgentInfo, coderAgentInfo, analyzerAgentInfo, codeFixerAgentInfo];
 
 // src/AiTool/createNewProject.ts
-var prompt = `You are an AiTool designed to assist users in creating new projects. Follow these guidelines:
+var prompt2 = `You are an AiTool designed to assist users in creating new projects. Follow these guidelines:
 
 1. **Gather Information:**
    - Begin by asking the user for essential project details, including:
@@ -3148,7 +3660,7 @@ var prompt = `You are an AiTool designed to assist users in creating new project
 var createNewProject_default = {
   name: "createNewProject",
   description: "Creates a new project",
-  prompt,
+  prompt: prompt2,
   formatInput: (params) => {
     return `<project_name>${params}</project_name>`;
   },
@@ -3159,7 +3671,7 @@ var createNewProject_default = {
 };
 
 // src/AiTool/generateGitCommitMessage.ts
-var prompt2 = `
+var prompt3 = `
 You are an advanced assistant specialized in creating concise and accurate Git commit messages. When you receive:
 - A Git diff inside the <tool_input> tag.
 - Additional user-supplied context inside the <tool_input_context> tag (if any).
@@ -3190,7 +3702,7 @@ Follow the same structure for any new input. Never repeat questions; focus on ge
 var generateGitCommitMessage_default = {
   name: "generateGitCommitMessage",
   description: "Generates git commit messages from git diff output",
-  prompt: prompt2,
+  prompt: prompt3,
   formatInput: (params) => {
     let ret = `<tool_input>
 ${params.diff}
@@ -3215,7 +3727,7 @@ ${output}`);
 };
 
 // src/AiTool/generateGithubPullRequestDetails.ts
-var prompt3 = `
+var prompt4 = `
 # Generate Github Pull Request Details
 
 You are given:
@@ -3299,7 +3811,7 @@ Use the above format whenever you receive <tool_input> that may include a branch
 var generateGithubPullRequestDetails_default = {
   name: "generateGithubPullRequestDetails",
   description: "Generates a GitHub pull request title and description from git commits",
-  prompt: prompt3,
+  prompt: prompt4,
   formatInput: (params) => {
     return `<tool_input>
 <tool_input_branch_name>${params.branchName}</tool_input_branch_name>${params.context ? `
@@ -3332,7 +3844,7 @@ ${output}`);
 };
 
 // src/AiTool/generateProjectConfig.ts
-var prompt4 = `You are an analyzer agent responsible for examining project files and generating appropriate polkacodes configuration. Your task is to:
+var prompt5 = `You are an analyzer agent responsible for examining project files and generating appropriate polkacodes configuration. Your task is to:
 
 1. Read and analyze the provided files using tool_read_file to understand:
    - Build tools and package manager (e.g., bun, npm)
@@ -3394,7 +3906,7 @@ The configuration should accurately reflect the project's structure, tools, and
 var generateProjectConfig_default = {
   name: "generateProjectConfig",
   description: "Analyzes project files to generate polkacodes config sections",
-  prompt: prompt4,
+  prompt: prompt5,
   formatInput: () => {
     return "";
   },
@@ -3442,65 +3954,6 @@ var generateGitCommitMessage = makeTool(generateGitCommitMessage_default);
 var generateGithubPullRequestDetails = makeTool(generateGithubPullRequestDetails_default);
 var generateProjectConfig = makeAgentTool(generateProjectConfig_default);
 var createNewProject = makeAgentTool(createNewProject_default);
-
-// src/config.ts
-import { z } from "zod";
-var providerModelSchema = z.object({
-  provider: z.string().optional(),
-  model: z.string().optional(),
-  parameters: z.record(z.string(), z.any()).optional()
-});
-var agentSchema = providerModelSchema.extend({
-  initialContext: z.object({
-    maxFileCount: z.number().int().positive().optional(),
-    excludes: z.array(z.string()).optional()
-  }).optional()
-});
-var configSchema = z.object({
-  agent: z.string().optional(),
-  prices: z.record(
-    z.string(),
-    // provider
-    z.record(
-      z.string(),
-      // model
-      z.object({
-        inputPrice: z.number().optional(),
-        outputPrice: z.number().optional(),
-        cacheWritesPrice: z.number().optional(),
-        cacheReadsPrice: z.number().optional()
-      })
-    )
-  ).optional(),
-  providers: z.record(
-    z.string(),
-    z.object({
-      apiKey: z.string().optional(),
-      defaultModel: z.string().optional(),
-      defaultParameters: z.record(z.string(), z.any()).optional()
-    })
-  ).optional(),
-  defaultProvider: z.string().optional(),
-  defaultModel: z.string().optional(),
-  defaultParameters: z.record(z.string(), z.any()).optional(),
-  maxMessageCount: z.number().int().positive().optional(),
-  budget: z.number().positive().optional(),
-  scripts: z.record(
-    z.string(),
-    z.string().or(
-      z.object({
-        command: z.string(),
-        description: z.string()
-      })
-    )
-  ).optional(),
-  agents: z.record(z.string(), agentSchema).optional(),
-  commands: z.object({
-    default: providerModelSchema.optional()
-  }).catchall(providerModelSchema).optional(),
-  rules: z.array(z.string()).optional().or(z.string()).optional(),
-  excludeFiles: z.array(z.string()).optional()
-}).strict();
 export {
   AgentBase,
   AiServiceBase,
@@ -3509,9 +3962,11 @@ export {
   ArchitectAgent,
   CodeFixerAgent,
   CoderAgent,
+  KnowledgeManagementPolicy,
   MockProvider,
   MultiAgent,
   PermissionLevel,
+  Policies,
   TaskEventKind,
   ToolResponseType,
   UsageMeter,
@@ -3564,5 +4019,6 @@ export {
   searchFiles_default as searchFiles,
   systemInformation,
   toolUsePrompt,
+  updateKnowledge_default as updateKnowledge,
   writeToFile_default as writeToFile
 };