the-citadel 0.5.2 → 0.5.4

package/dist/core/agent.d.ts

@@ -26,7 +26,7 @@ export declare abstract class CoreAgent {
     protected getDynamicTools(_context?: AgentContext): Promise<Record<string, Tool>>;
     private mcpLoaded;
     protected executeGenerateText(messages: ModelMessage[]): Promise<Awaited<ReturnType<typeof generateText>>>;
-    private registerBuiltinTools;
+    protected registerBuiltinTools(): Promise<void>;
     protected registerTool<T extends z.ZodTypeAny, R>(name: string, description: string, schema: T, execute: (args: z.infer<T>) => Promise<R>): void;
     /**
      * Registers an AI SDK Tool directly, ensuring its schema is discoverable.

package/dist/index.js

@@ -94148,7 +94148,7 @@ class CoreAgent {
     return { allowed: true };
   }
   async run(prompt, context2) {
-    logger.info(`[${this.role}] Running...`, { role: this.role });
+    logger.info(`[${this.role}] Running...`, { role: this.role, prompt: prompt.length > 400 ? prompt.slice(0, 400) + "..." : prompt });
     await this.registerBuiltinTools();
     this.dynamicTools = await this.getDynamicTools(context2);
     const instructionService = getInstructionService();
@@ -94185,22 +94185,25 @@ Request: ${prompt}`
       const { maxHistoryMessages = 20, maxToolResponseSize = 50000, maxMessageSize = 1e5 } = config2.context || {};
       if (messages.length > maxHistoryMessages) {
         const systemMessage = messages[0];
-        const lastN = messages.slice(-maxHistoryMessages);
+        const userRequest = messages[1];
+        const lastNCount = Math.max(0, maxHistoryMessages - 2);
+        const lastN = messages.slice(-lastNCount);
         if (lastN.length > 0 && lastN[0] && lastN[0].role === "tool") {
           const toolResult = lastN[0];
           const originalIndex = messages.indexOf(toolResult);
           if (originalIndex > 0) {
             const preceding = messages[originalIndex - 1];
-            if (preceding && preceding !== toolResult) {
+            if (preceding && preceding !== userRequest && preceding !== systemMessage) {
               lastN.unshift(preceding);
             }
           }
         }
         messages.length = 0;
+        if (systemMessage)
+          messages.push(systemMessage);
+        if (userRequest && userRequest !== systemMessage)
+          messages.push(userRequest);
         messages.push(...lastN);
-        if (systemMessage) {
-          messages.unshift(systemMessage);
-        }
       }
       const result = await this.executeGenerateText(messages);
       console.log("DEBUG: result.usage", JSON.stringify(result.usage));
@@ -94498,15 +94501,15 @@ var createFailWorkTool = (_context) => {
 };
 
 // src/tools/shell.ts
-import { exec as exec2 } from "node:child_process";
-import { promisify } from "node:util";
-var execAsync = promisify(exec2);
+import { spawn as spawn3 } from "node:child_process";
 var runCommandTool = {
   name: "run_command",
-  description: "Execute a shell command (e.g. to run tests)",
+  description: "Execute a shell command (e.g. to run tests). Supports timeouts and background execution.",
   schema: exports_external.object({
     command: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional().describe('The shell command to execute as a single string (e.g., "ls -la", "npm test")'),
-    cmd: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional().describe("Alternative: command as string or array of arguments")
+    cmd: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional().describe("Alternative: command as string or array of arguments"),
+    timeout: exports_external.number().optional().default(60000).describe("Timeout in milliseconds (default: 60000)"),
+    background: exports_external.boolean().optional().default(false).describe("Whether to run the command in the background (default: false)")
   }).loose(),
   handler: async (args) => {
     let command;
@@ -94521,31 +94524,90 @@ var runCommandTool = {
         error: 'Either "command" or "cmd" parameter must be provided'
       };
     }
-    logger.debug(`[Shell] Running command: ${command}`);
-    try {
-      const { stdout, stderr } = await execAsync(command);
-      if (command.trim().startsWith("git ")) {
-        let autoSync = true;
-        try {
-          const config2 = getConfig();
-          autoSync = config2.pearls.autoSync !== false;
-        } catch {}
-        if (autoSync) {
-          logger.info(`[Shell] Git operation detected. Triggering Pearls sync.`);
-          await getPearls().sync();
-        }
+    const timeout = args.timeout ?? 60000;
+    const background = args.background === true;
+    logger.debug(`[Shell] Running command: ${command} (timeout: ${timeout}, background: ${background})`);
+    if (background) {
+      try {
+        const child = spawn3(command, {
+          shell: true,
+          detached: true,
+          stdio: "ignore"
+        });
+        child.unref();
+        return {
+          success: true,
+          message: `Started background process with PID ${child.pid}`,
+          pid: child.pid
+        };
+      } catch (error48) {
+        return {
+          success: false,
+          error: error48 instanceof Error ? error48.message : String(error48)
+        };
       }
-      return { success: true, stdout: stdout.trim(), stderr: stderr.trim() };
-    } catch (error48) {
-      const errorMessage = error48 instanceof Error ? error48.message : String(error48);
-      const errObj = error48;
-      return {
-        success: false,
-        error: errorMessage,
-        stdout: errObj.stdout,
-        stderr: errObj.stderr
-      };
     }
+    return new Promise((resolve8) => {
+      const child = spawn3(command, { shell: true });
+      let stdout = "";
+      let stderr = "";
+      const timer = setTimeout(() => {
+        try {
+          process.kill(-child.pid, "SIGTERM");
+        } catch (e) {
+          child.kill("SIGTERM");
+        }
+        resolve8({
+          success: false,
+          error: `Command timed out after ${timeout}ms`,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      }, timeout);
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", async (code) => {
+        clearTimeout(timer);
+        if (command.trim().startsWith("git ")) {
+          let autoSync = true;
+          try {
+            const config2 = getConfig();
+            autoSync = config2.pearls.autoSync !== false;
+          } catch {}
+          if (autoSync) {
+            logger.info(`[Shell] Git operation detected. Triggering Pearls sync.`);
+            await getPearls().sync();
+          }
+        }
+        if (code === 0) {
+          resolve8({
+            success: true,
+            stdout: stdout.trim(),
+            stderr: stderr.trim()
+          });
+        } else {
+          resolve8({
+            success: false,
+            error: `Command exited with code ${code}`,
+            stdout: stdout.trim(),
+            stderr: stderr.trim()
+          });
+        }
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve8({
+          success: false,
+          error: err.message,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      });
+    });
   }
 };
 
@@ -96255,7 +96317,7 @@ async function loadConfig2() {
 }
 
 // src/core/pearls.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { resolve as resolve10 } from "node:path";
 var PearlStatusSchema2 = exports_external.enum([
   "open",
@@ -96339,7 +96401,7 @@ ${err.message}`);
   }
   async execute(command, args, cwd2) {
     return new Promise((resolve11, reject) => {
-      const child = spawn3(command, args, { cwd: cwd2 });
+      const child = spawn4(command, args, { cwd: cwd2 });
       let stdout = "";
       let stderr = "";
       child.stdout.on("data", (data) => {

package/dist/tools/shell.d.ts

@@ -5,25 +5,14 @@ export declare const runCommandTool: {
     schema: z.ZodObject<{
         command: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
         cmd: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        background: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, z.core.$loose>;
     handler: (args: {
         command?: string | string[];
         cmd?: string | string[];
+        timeout?: number;
+        background?: boolean;
         [key: string]: unknown;
-    }) => Promise<{
-        success: boolean;
-        error: string;
-        stdout?: undefined;
-        stderr?: undefined;
-    } | {
-        success: boolean;
-        stdout: string;
-        stderr: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        stdout: string | undefined;
-        stderr: string | undefined;
-    }>;
+    }) => Promise<unknown>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "the-citadel",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "A deterministic agent orchestration system for Knowledge Work",
   "module": "src/index.ts",
   "type": "module",