aegiscode 6.1.0 → 6.2.0

package/vendor/desktop/lib/local/prompt.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * prompt.js — the desktop client's system prompt (client half of
+ * aegiscodex-dev's tool calling).
+ *
+ * aegiscodex-dev sends a real persona on every provider turn
+ * (src/backend.js MAIN_CHAT_PROMPT plus a docs/operating-context.md block).
+ * The desktop renderer used to send nothing at all, so every model answered a
+ * bare user string with no identity, no work rules and no idea which machine
+ * it was on — hence the "which OS are you using?" round trips.
+ *
+ * MAIN_CHAT_PROMPT below is the same identity + truthfulness rule set, ported
+ * verbatim where it still applies, including the CLI's "delegate with the
+ * task tool" rule now that the desktop has a subagent runner (engine.js
+ * runSubagent). One naming deviation from the CLI text: the tool names are
+ * readFile/writeFile/editFile/listDir/glob/grep/exec/task (lowerCamelCase,
+ * matching this repo's existing tool vocabulary — see
+ * desktop/lib/local/tools.js) rather than the CLI's Read/Write/Edit/Grep/
+ * Bash/Task.
+ *
+ * The environment preamble names the platform, the home directory and the
+ * repo roots the host already knows (main.js), so the model stops asking.
+ */
+
+/** Identity + work rules. Ported from aegiscodex-dev src/backend.js. */
+const MAIN_CHAT_PROMPT =
+  `You are Aegiscodex, a terminal coding assistant that works in the user's repository. ` +
+  `Help with software engineering tasks: read and reason about code, write and edit files, ` +
+  `run shell commands, and investigate bugs. Work rules:\n` +
+  `- Use tools silently. A one-line reason is enough; do not narrate your plan as a story. ` +
+  `- Never claim what a tool found or what a command returned before the tool actually runs. ` +
+  `  Report only the results you really received. ` +
+  `- Act, don't just inspect. After at most 2 rounds of reading or exploration, start making ` +
+  `  changes with writeFile or editFile. Reconnaissance is not progress — implement, then verify.\n` +
+  `- When you have what you need, stop using tools and give a concise, direct answer to the ` +
+  `  user's question. Never end your turn with an intention like "Let me check…" or "I'll now…" ` +
+  `  — that is not an answer. ` +
+  `- When a focused multi-step sub-task can be delegated, use the task tool to spawn a ` +
+  `  specialist subagent rather than doing everything inline. ` +
+  `- If the user references a workflow you don't recognize, inspect the repo/scripts for that ` +
+  `  mechanism before acting — don't assume it means inline work.`;
+
+/** The tools the desktop actually advertises (kept in step with tools.js). */
+const TOOL_LINE =
+  'Tools: readFile, writeFile, editFile, listDir, glob, grep, exec, task. Paths are absolute; ' +
+  'exec runs in a persistent shell session on this machine — cd and exported env vars carry ' +
+  'across calls within the turn, like a real terminal. task spawns a specialist subagent ' +
+  '(its own tool loop, same model) for a focused, self-contained piece of work.';
+
+/**
+ * Render the environment preamble. Everything is optional: a missing field is
+ * simply omitted, so a headless caller can build a persona with nothing but
+ * the identity block.
+ */
+function environmentPreamble(env = {}) {
+  const { platform, arch, homedir, cwd, roots, appVersion, model } = env || {};
+  const bits = [];
+  if (platform) bits.push(`platform: ${platform}${arch ? ` (${arch})` : ''}`);
+  if (homedir) bits.push(`home directory: ${homedir}`);
+  if (cwd) bits.push(`working directory: ${cwd}`);
+  if (model) bits.push(`model: ${model}`);
+  if (appVersion) bits.push(`AEGIS Desktop ${appVersion}`);
+
+  const rootList = Array.isArray(roots) ? roots.filter(Boolean) : [];
+  const lines = [];
+  if (bits.length) lines.push(bits.join('\n'));
+  if (rootList.length) {
+    lines.push(`repo roots:\n${rootList.map((r) => `  - ${r}`).join('\n')}`);
+  }
+  if (!lines.length) return '';
+  return `# Environment\n${lines.join('\n')}`;
+}
+
+/**
+ * The full system prompt for a desktop chat turn: identity + work rules +
+ * the tool line + the environment block. Never empty.
+ */
+function buildSystemPrompt(env = {}) {
+  const parts = [MAIN_CHAT_PROMPT, TOOL_LINE];
+  const preamble = environmentPreamble(env);
+  if (preamble) parts.push(preamble);
+  return parts.join('\n\n');
+}
+
+module.exports = {
+  MAIN_CHAT_PROMPT,
+  TOOL_LINE,
+  environmentPreamble,
+  buildSystemPrompt,
+};

package/vendor/desktop/lib/local/shell.js

@@ -0,0 +1,208 @@
+'use strict';
+
+/**
+ * shell.js — a persistent shell session for the `exec` tool, ported from
+ * aegiscodex-dev's src/shell.js (client half of the same design).
+ *
+ * The desktop `exec` tool used to spawn ONE process per call: `cd /foo` in
+ * one turn had no effect on the next call, so a model that wanted to work
+ * inside a subdirectory had to prefix every single command with `cd X &&`.
+ * This keeps ONE long-lived shell per chat turn — bash on macOS/Linux,
+ * PowerShell on Windows (no bash there by default) — feeding it commands over
+ * stdin and framing each command's output with a per-session random sentinel
+ * printed alongside the exit code. On bash, stderr is merged into stdout
+ * (`exec 2>&1`) so ordering is preserved; PowerShell's stderr pipe is merged
+ * the same way by listening on both streams.
+ *
+ * Self-contained (node:child_process + node:crypto only) and never throws:
+ * run() always resolves { content, isError }. If the session can't start or
+ * dies, run() falls back to a one-shot spawn so `exec` keeps working.
+ */
+
+const { spawn } = require('node:child_process');
+const crypto = require('node:crypto');
+
+const IS_WIN32 = process.platform === 'win32';
+const OUTPUT_CAP = 30_000;
+const MAX_TIMEOUT = 600_000;
+const DEFAULT_TIMEOUT = 120_000;
+
+function cap(s) {
+  return s.length > OUTPUT_CAP ? `${s.slice(0, OUTPUT_CAP)}\n… (truncated)` : s;
+}
+
+/** One-shot fallback — the pre-session behavior, used when no live session. */
+function oneShotShell({ command, timeout = DEFAULT_TIMEOUT, working_directory } = {}) {
+  return new Promise((resolve) => {
+    const cmd = IS_WIN32 ? (process.env.ComSpec || 'cmd.exe') : (process.env.SHELL || '/bin/sh');
+    const arg = IS_WIN32 ? '/d /s /c' : '-c';
+    const child = spawn(cmd, [arg, String(command || '')], {
+      cwd: working_directory || process.cwd(),
+      timeout: Math.min(Number(timeout) || DEFAULT_TIMEOUT, MAX_TIMEOUT),
+    });
+    let out = '';
+    let err = '';
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.on('data', (d) => { err += d; });
+    child.on('error', (e) => resolve({ content: `error: ${e.message}`, isError: true }));
+    child.on('close', (code) => {
+      const body = `${out}${err ? `\n${err}` : ''}`.trim() || `(exit ${code})`;
+      resolve({ content: cap(body), isError: code !== 0 });
+    });
+  });
+}
+
+class ShellSession {
+  constructor({ cwd } = {}) {
+    this.sentinel = `__AEGIS_SH_${crypto.randomBytes(8).toString('hex')}__`;
+    this.marker = `${this.sentinel}EXIT:`;
+    this.buf = '';
+    this.alive = false;
+    this._pending = null; // resolver-scan for the in-flight command
+    this._start(cwd);
+  }
+
+  _start(cwd) {
+    try {
+      this.child = IS_WIN32
+        // -Command - reads the script from stdin as a non-interactive session,
+        // so there are no prompts to pollute output, but state still persists.
+        ? spawn('powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', '-'], {
+          cwd: cwd || process.cwd(),
+          env: process.env,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        })
+        // No args → the shell reads commands from stdin as a non-interactive
+        // script, so there are no prompts to pollute output, but state persists.
+        : spawn(process.env.SHELL || '/bin/bash', [], {
+          cwd: cwd || process.cwd(),
+          env: process.env,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    } catch {
+      this.alive = false;
+      return;
+    }
+    this.alive = true;
+    const onData = (d) => { this.buf += d.toString(); if (this._pending) this._pending(); };
+    this.child.stdout.on('data', onData);
+    this.child.stderr.on('data', onData);
+    this.child.on('exit', () => { this.alive = false; if (this._pending) this._pending(true); });
+    this.child.on('error', () => { this.alive = false; if (this._pending) this._pending(true); });
+    // Merge stderr into stdout for the whole session so output ordering is
+    // faithful and the sentinel (printed to fd1) always lands after it.
+    // PowerShell errors already arrive on the stderr pipe onData folds in
+    // above, so only bash needs the explicit redirect.
+    if (!IS_WIN32) {
+      try { this.child.stdin.write('exec 2>&1\n'); } catch { this.alive = false; }
+    }
+  }
+
+  /**
+   * Run one command in the session. Resolves { content, isError }. A dead or
+   * unstartable session (or a working_directory that must not persist)
+   * degrades gracefully. `working_directory` is scoped to this one command (a
+   * subshell on bash, Push-Location/Pop-Location on PowerShell) so it doesn't
+   * move the session's cwd.
+   */
+  run(command, { timeout = DEFAULT_TIMEOUT, working_directory } = {}) {
+    if (!this.alive || !this.child) {
+      return oneShotShell({ command, timeout, working_directory });
+    }
+    let cmd = String(command || '');
+
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this._pending = null;
+        resolve(result);
+      };
+
+      const timer = setTimeout(() => {
+        // A hung command (e.g. one that reads stdin) can never reach the
+        // sentinel — kill the poisoned session and report what we have.
+        const partial = cap(this.buf.trim());
+        this.dispose();
+        finish({ content: `${partial}${partial ? '\n' : ''}(timed out after ${timeout}ms)`, isError: true });
+      }, Math.min(Number(timeout) || DEFAULT_TIMEOUT, MAX_TIMEOUT));
+
+      this._pending = (died) => {
+        if (died && !this.buf.includes(this.marker)) {
+          finish({ content: cap(this.buf.trim()) || '(shell session ended)', isError: true });
+          return;
+        }
+        const idx = this.buf.indexOf(this.marker);
+        if (idx === -1) return; // sentinel not here yet — wait for more data
+        const after = this.buf.slice(idx + this.marker.length);
+        const nl = after.indexOf('\n');
+        if (nl === -1) return; // exit-code line still arriving
+        const code = parseInt(after.slice(0, nl), 10);
+        const output = this.buf.slice(0, idx).replace(/\n+$/, '');
+        this.buf = after.slice(nl + 1); // leftover for the next command (usually '')
+        finish({ content: cap(output || `(exit ${code})`), isError: code !== 0 });
+      };
+
+      // Send the command, then print the sentinel + exit code on its own line.
+      let script;
+      if (IS_WIN32) {
+        // Push-Location/Pop-Location scope working_directory to this one
+        // command without moving the session's persistent cwd. $__c captures
+        // the real exit status before Pop-Location's own success would
+        // otherwise overwrite $?/$LASTEXITCODE.
+        const body = cmd.trim() ? cmd : 'Write-Output $null';
+        const exitCapture =
+          '$__c = if ($LASTEXITCODE -ne $null) { $LASTEXITCODE } elseif ($?) { 0 } else { 1 }';
+        script = working_directory
+          ? `Push-Location -LiteralPath ${pshq(working_directory)}\ntry {\n${body}\n${exitCapture}\n} finally {\nPop-Location\n}\n`
+          : `${body}\n${exitCapture}\n`;
+        script += `Write-Output ("${this.marker}" + $__c)\n`;
+      } else {
+        // The command runs in a brace group with its stdin redirected from
+        // /dev/null: a group (not a subshell) keeps cd/export state
+        // persisting, and `</dev/null` stops the command from consuming the
+        // control channel. Without this, any stdin-reading command (cat,
+        // read, a REPL, ssh, a y/n prompt) swallows the sentinel line that
+        // follows it — hanging the whole session until the timeout, and
+        // echoing commands (cat) even splice the sentinel into their output
+        // and mis-resolve with garbage. working_directory runs in a subshell
+        // (parens, not the brace group) so it doesn't move the session's cwd.
+        if (working_directory) cmd = `( cd ${shq(working_directory)} && ${cmd} )`;
+        const body = cmd.trim() ? cmd : ':';
+        script = `{ ${body}\n} </dev/null\nprintf '\\n%s%d\\n' '${this.sentinel}EXIT:' "$?"\n`;
+      }
+      try {
+        this.child.stdin.write(script);
+      } catch {
+        this.alive = false;
+        oneShotShell({ command, timeout, working_directory }).then(finish);
+        return;
+      }
+      // Data may already be buffered (fast commands) — scan once now.
+      if (this._pending) this._pending();
+    });
+  }
+
+  dispose() {
+    this.alive = false;
+    if (this.child) {
+      try { this.child.stdin.end(); } catch { /* already gone */ }
+      try { this.child.kill('SIGKILL'); } catch { /* already gone */ }
+      this.child = null;
+    }
+  }
+}
+
+// Minimal single-quote shell-escape for a path.
+function shq(s) {
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+
+// Minimal single-quote escape for a PowerShell -LiteralPath (double up ').
+function pshq(s) {
+  return `'${String(s).replace(/'/g, "''")}'`;
+}
+
+module.exports = { ShellSession, oneShotShell, IS_WIN32 };