@causyne/agent 1.10.21 → 1.11.0

package/src/tools/peerAgent.ts

@@ -0,0 +1,116 @@
+/**
+ * Causyne Peer Agent Tool
+ *
+ * Delegates a bounded task to an external ACP agent that the user configured
+ * in `~/.causyne/peers.json`. The model chooses a profile and writes a prompt;
+ * it never chooses the executable, arguments, working directory, or
+ * environment. Those come from the user's file and nowhere else.
+ */
+
+import { AcpClient } from '../acp/client.js';
+import type { RequestPermissionRequest, RequestPermissionResponse } from '../acp/protocol.js';
+import { getPeerProfile, loadPeerProfiles, peerEnvironment } from '../acp/peerProfiles.js';
+import type { PeerProfile } from '../acp/peerProfiles.js';
+
+export interface PeerAgentArgs {
+  peer?: string;
+  prompt: string;
+  timeoutSeconds?: number;
+}
+
+const MAX_PROMPT_CHARS = 100_000;
+const READ_ONLY_KINDS = new Set(['read', 'search', 'fetch', 'think']);
+
+function selectPermission(profile: PeerProfile, request: RequestPermissionRequest): RequestPermissionResponse['outcome'] {
+  const kind = request.toolCall.kind;
+  const readLike = typeof kind === 'string' && READ_ONLY_KINDS.has(kind);
+  if (profile.policy === 'read-only' && !readLike) {
+    const reject = request.options.find((option) => option.kind === 'reject_once' || option.kind === 'reject_always');
+    return reject ? { outcome: 'selected', optionId: reject.optionId } : { outcome: 'cancelled' };
+  }
+  const allow = request.options.find((option) => option.kind === 'allow_once' || option.kind === 'allow_always');
+  return allow ? { outcome: 'selected', optionId: allow.optionId } : { outcome: 'cancelled' };
+}
+
+export const peerAgentTool = {
+  schema: {
+    name: 'peer_agent_delegate',
+    description: 'Delegate a bounded task to a peer ACP agent that the user configured in the peers file. The model supplies the peer id and the prompt only; the executable, arguments, working directory, environment, and permission policy come from the user configuration. Peers default to rejecting mutating permission requests; the external agent decides how to honor that policy.',
+    parameters: {
+      type: 'object',
+      properties: {
+        peer: {
+          type: 'string',
+          description: 'Id of a configured peer profile from the peers file.'
+        },
+        prompt: {
+          type: 'string',
+          description: 'Task instructions and context for the peer agent.'
+        },
+        timeoutSeconds: {
+          type: 'number',
+          description: 'Optional shorter timeout in seconds, bounded by the profile timeout.'
+        }
+      },
+      required: ['peer', 'prompt']
+    }
+  },
+  async execute(args: PeerAgentArgs): Promise<{ success: boolean; output?: string; error?: string }> {
+    const peerId = String(args.peer || '').trim();
+    const prompt = String(args.prompt || '').trim().slice(0, MAX_PROMPT_CHARS);
+    if (!peerId) {
+      const configured = loadPeerProfiles().map((profile) => profile.id);
+      return {
+        success: false,
+        error: configured.length > 0
+          ? `A peer id is required. Configured peers: ${configured.join(', ')}.`
+          : 'No peer profiles are configured. Add one to the peers file first.'
+      };
+    }
+    if (!prompt) {
+      return { success: false, error: 'A prompt is required for peer delegation.' };
+    }
+
+    const profile = getPeerProfile(peerId);
+    if (!profile) {
+      return { success: false, error: `Unknown peer profile: ${peerId}.` };
+    }
+
+    const requested = typeof args.timeoutSeconds === 'number' && Number.isFinite(args.timeoutSeconds)
+      ? Math.round(args.timeoutSeconds)
+      : profile.timeoutSeconds;
+    const timeoutSeconds = Math.max(5, Math.min(Math.min(profile.timeoutSeconds, requested), 1800));
+
+    const client = new AcpClient({
+      command: profile.command,
+      args: profile.args,
+      cwd: profile.cwd ?? process.cwd(),
+      env: peerEnvironment(profile),
+      promptTimeoutMs: timeoutSeconds * 1000,
+      permissionHandler: async (request) => selectPermission(profile, request)
+    });
+
+    try {
+      await client.start();
+      const sessionId = await client.newSession(profile.cwd ?? process.cwd());
+      const result = await client.prompt(sessionId, prompt);
+      if (result.stopReason === 'cancelled') {
+        return { success: false, error: 'The peer agent cancelled the task.' };
+      }
+      if (result.stopReason === 'refusal') {
+        return { success: false, error: 'The peer agent refused the task.' };
+      }
+      return {
+        success: true,
+        output: result.text.trim() || 'Peer agent completed the task without a written summary.'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Peer agent delegation failed.'
+      };
+    } finally {
+      await client.close();
+    }
+  }
+};

package/src/tools/registry.js

@@ -1,6 +1,8 @@
 import { creativeApps } from './creativeApps.js';
 import { computerUse } from './computerUse.js';
 import { uiForge } from './uiForge.js';
+import { documentForgeTool } from './documentForge.js';
+import { peerAgentTool } from './peerAgent.js';
 import { sysRun, sysRunBg } from './sysRun.js';
 import { fsRead } from './fsRead.js';
 import { fsWrite } from './fsWrite.js';
@@ -123,7 +125,7 @@ const TOOL_MODULES = [
   gameShaderForge, gameSceneBuilder, gameEntitySpawner,
   gameTilemapGenerator, gameUiHudBuilder, gameEconomyBalancer,
   gameDataForge, gameWebRuntimeInspector, gameCanvasAudit, readNativeSkill, createSkill, creativeApps,
-  computerUse, uiForge
+  computerUse, uiForge, documentForgeTool, peerAgentTool
 ];
 
 // Base static definitions (backwards compatible). Order is preserved from the

package/src/tui/completion.js

@@ -59,6 +59,7 @@ export function score(candidate, query) {
 
   const base = haystack.slice(haystack.lastIndexOf('/') + 1);
   if (base.startsWith(needle)) return 800 - candidate.length;
+  if (haystack.includes(needle)) return 700 - candidate.length;
   if (base.includes(needle)) return 600 - candidate.length;
 
   // Subsequence: every character of the query in order, gaps allowed. This is
@@ -79,17 +80,25 @@ export function score(candidate, query) {
 /**
  * Score, sort and cap — and report how many matched BEFORE the cap.
  *
- * The cap exists for the file index, which can hold tens of thousands of paths.
- * But the picker's "… N more" line was computed from the capped array, so with
- * 115 skill entries it announced "42 more" when 107 were reachable by scrolling.
- * A count that is wrong is worse than no count: it tells the user to stop
- * looking. The total travels with the items so the caller can say the truth.
+ * If focusDir is supplied (e.g. active subproject like 'pixel2d games'),
+ * items belonging to that directory receive a priority boost so the user's
+ * active workspace files are never buried by unrelated paths.
  */
-function rank(items, query, limit = 50) {
+function rank(items, query, limit = 50, focusDir = null) {
   const scored = [];
+  const focusPrefix = focusDir
+    ? (focusDir.endsWith('/') ? focusDir.toLowerCase() : focusDir.toLowerCase() + '/')
+    : null;
+
   for (const item of items) {
-    const value = score(item.match !== undefined ? item.match : item.value, query);
-    if (value >= 0) scored.push({ item, value });
+    const val = item.match !== undefined ? item.match : item.value;
+    let value = score(val, query);
+    if (value >= 0) {
+      if (focusPrefix && val.toLowerCase().startsWith(focusPrefix)) {
+        value += 3000;
+      }
+      scored.push({ item, value });
+    }
   }
   scored.sort((a, b) => b.value - a.value);
   const ranked = scored.slice(0, limit).map((entry) => entry.item);
@@ -227,6 +236,8 @@ export class FileIndex {
         if (entry.isDirectory()) {
           if (SKIP_DIRECTORIES.has(entry.name) || depth >= MAX_INDEX_DEPTH) continue;
           queue.push({ dir: full, depth: depth + 1 });
+          const relDir = path.relative(this.root, full) + '/';
+          if (isTerminalSafe(relDir)) found.push(relDir);
           continue;
         }
         if (!entry.isFile()) continue;
@@ -321,10 +332,26 @@ export function detectTrigger(text, cursor) {
     };
   }
 
-  const mention = before.match(/(?:^|\s)@([^\s@]*)$/);
+  // 1. Quoted @ file mention: @"pixel2d games/ or @'pixel2d games/
+  // Supports spaces in directory or file names
+  const quotedMention = before.match(/(?:^|\s)@(["'])([^"']*)$/);
+  if (quotedMention) {
+    const quote = quotedMention[1];
+    const query = quotedMention[2];
+    return {
+      kind: 'file',
+      quote,
+      start: cursor - query.length - 2, // accounts for @ and quote char
+      query
+    };
+  }
+
+  // 2. Unquoted @ file mention: @alpha or @src/
+  const mention = before.match(/(?:^|\s)@([^\s@"']*)$/);
   if (mention) {
     return {
       kind: 'file',
+      quote: null,
       start: cursor - mention[1].length - 1,
       query: mention[1]
     };
@@ -356,15 +383,41 @@ export function suggest(text, cursor, options = {}) {
 
   const root = options.root || process.cwd();
   const index = options.index;
+  const focusDir = options.focusDir || null;
   if (index && !index.isReady) index.ensure();
 
-  const pool = index && index.isReady && trigger.query.includes('/') === false && trigger.query
-    ? index.entries.map((relative) => ({
-        value: relative, match: relative, label: relative, description: ''
-      }))
-    : directoryItems(root, trigger.query);
+  let pool;
+  if (index && index.isReady && trigger.query) {
+    pool = index.entries.map((relative) => ({
+      value: relative,
+      match: relative,
+      label: relative,
+      description: relative.endsWith('/') ? 'directory' : ''
+    }));
+  } else {
+    pool = directoryItems(root, trigger.query);
+    if (focusDir) {
+      const focusTarget = path.resolve(root, focusDir);
+      try {
+        if (fs.existsSync(focusTarget) && fs.statSync(focusTarget).isDirectory()) {
+          const focusedItems = directoryItems(focusTarget, trigger.query).map((item) => ({
+            ...item,
+            value: `${focusDir}/${item.value}`,
+            match: `${focusDir}/${item.value}`,
+            label: `${focusDir}/${item.label}`
+          }));
+          pool = pool.concat(focusedItems);
+        }
+      } catch (e) {}
+    }
+  }
+
+  // If index had no ready matches for a path with slashes, fall back to directory items
+  if (pool.length === 0 && trigger.query.includes('/')) {
+    pool = directoryItems(root, trigger.query);
+  }
 
-  const items = rank(pool, trigger.query.slice(trigger.query.lastIndexOf('/') + 1));
+  const items = rank(pool, trigger.query, 50, focusDir);
   if (items.length === 0) return null;
   return { ...trigger, items, total: items.total };
 }
@@ -374,39 +427,42 @@ export function applyCompletion(text, cursor, trigger, item) {
   if (trigger.kind === 'command-argument') {
     const head = text.slice(0, trigger.start);
     const tail = text.slice(cursor);
-
-    // A COMPLETE argument gets a trailing space; a partial one does not.
-    //
-    // This was written the other way round, on the theory that a space would
-    // reopen the picker on a value still being edited. It does not — a
-    // completed argument followed by a space matches no trigger at all. What it
-    // actually did was run the user's next words straight into the argument:
-    // accepting `python/data-processing-pipelines` and typing a question gave
-    // `/skills python/data-processing-pipelineswhy my data is like this ?` and
-    // a "skill not found" error.
-    //
-    // The distinction is the same one file completion already makes between a
-    // directory and a file: a domain (`devops`) is a place you may want to
-    // descend into with `/`, so it gets no space; a full `domain/skill` id is
-    // finished, so it gets one and the next thing typed is the instruction.
     const complete = item.value.includes('/');
     const replaced = head + item.value + (complete ? ' ' : '');
     return { text: replaced + tail, cursor: replaced.length };
   }
 
-  const value = trigger.kind === 'command' ? item.value : '@' + item.value;
+  if (trigger.kind === 'command') {
+    const head = text.slice(0, trigger.start);
+    const tail = text.slice(cursor);
+    const replaced = head + item.value + ' ';
+    return { text: replaced + tail, cursor: replaced.length };
+  }
+
+  // trigger.kind === 'file'
   const head = text.slice(0, trigger.start);
   const tail = text.slice(cursor);
-  // A directory keeps the picker useful: no trailing space, so the next
-  // keystroke drills in rather than starting a new word.
-  //
-  // Everything else — including a skill picked from the slash menu, whose value
-  // is a whole `/skills domain/id` command — gets one, so the next thing typed
-  // is a new word rather than more of the last one. The exclusion that used to
-  // sit here for values containing a space was the same mistake as above: it
-  // made `/docker` complete to `/skills devops/docker-multi-stage-builds` with
-  // nothing after it, and the user's instruction fused onto the id.
-  const suffix = (trigger.kind === 'file' && item.value.endsWith('/')) ? '' : ' ';
+  const isDir = item.value.endsWith('/');
+  const hasSpace = item.value.includes(' ');
+  const quote = trigger.quote || (hasSpace ? '"' : '');
+
+  let value;
+  let suffix;
+  if (quote) {
+    if (isDir) {
+      // Drilling into directory: open quote without closing quote, no trailing space
+      value = `@${quote}${item.value}`;
+      suffix = '';
+    } else {
+      // Complete file: close quote and add trailing space
+      value = `@${quote}${item.value}${quote}`;
+      suffix = ' ';
+    }
+  } else {
+    value = '@' + item.value;
+    suffix = isDir ? '' : ' ';
+  }
+
   const replaced = head + value + suffix;
   return { text: replaced + tail, cursor: replaced.length };
 }

package/src/tui/prompt.js

@@ -20,7 +20,7 @@
 import { KeyDecoder, bracketedPaste } from './keys.js';
 import { LineEditor } from './lineEditor.js';
 import { PromptHistory } from './history.js';
-import { FileIndex, suggest, applyCompletion, renderPicker, MAX_VISIBLE } from './completion.js';
+import { FileIndex, suggest, applyCompletion, detectTrigger, renderPicker, MAX_VISIBLE } from './completion.js';
 import { paint, dim, bold, GLYPHS, terminalWidth, HAS_COLOR } from './theme.js';
 import { barBlock, GUTTER } from './block.js';
 import { visibleWidth, truncate, wrapBlock, shortenHome, safeDisplay } from './text.js';
@@ -84,6 +84,7 @@ export class ChatPrompt {
     this.out = options.out || process.stdout;
     this.input = options.input || process.stdin;
     this.root = options.root || process.cwd();
+    this.focusDir = options.focusDir || null;
     this.onInterrupt = options.onInterrupt || (() => {});
 
     // The Stage, when one is running. Null means the scrollback renderer, which
@@ -920,6 +921,14 @@ export class ChatPrompt {
   // Completion
   // -------------------------------------------------------------------------
 
+  /** Dynamically re-target the prompt root and optional focused subproject. */
+  setWorkingRoot(newRoot, focusDir = null) {
+    this.root = newRoot;
+    this.focusDir = focusDir;
+    this.index = new FileIndex(newRoot);
+    this.index.ensure();
+  }
+
   cursorOffset() {
     const before = this.editor.lines
       .slice(0, this.editor.line)
@@ -929,13 +938,14 @@ export class ChatPrompt {
 
   openCompletion(force = false) {
     const text = this.editor.getText();
-    const result = suggest(text, this.cursorOffset(), { root: this.root, index: this.index });
+    const result = suggest(text, this.cursorOffset(), {
+      root: this.root,
+      index: this.index,
+      focusDir: this.focusDir
+    });
     if (!result) {
       if (force) this.notice = 'nothing to complete here';
-      // Close a picker whose trigger has gone. refreshCompletion() documents
-      // this ("close it when the trigger is gone") but this early return never
-      // did it — so typing past the end of an argument left the suggestions on
-      // screen, still offering matches for text that was no longer there.
+      // Close a picker whose trigger has gone.
       this.completion = null;
       return;
     }
@@ -946,19 +956,9 @@ export class ChatPrompt {
   /** Re-run completion after an edit; close it when the trigger is gone. */
   refreshCompletion() {
     if (!this.completion) {
-      // `/` at the start and `@` anywhere open the picker without a keystroke,
-      // which is the behaviour both openclaw and opencode settled on.
       const text = this.editor.getText();
       const offset = this.cursorOffset();
-      const tail = text.slice(0, offset);
-      // `/` at the start, `@` anywhere, and the argument of a slash command all
-      // open the picker without a keystroke. The third is what makes `/skills d`
-      // suggest as you type instead of only after Tab — the behaviour both
-      // references settled on, and the reason a hundred-skill library is usable
-      // by someone who already knows the name they want.
-      const opens = /^\/[a-z0-9_?-]*$/i.test(tail)
-        || /(?:^|\s)@[^\s@]*$/.test(tail)
-        || /^\/[a-z0-9_?-]+[ \t]+\S*$/i.test(tail);
+      const opens = Boolean(detectTrigger(text, offset));
       if (opens) this.openCompletion(false);
       return;
     }