chainlesschain 0.162.188 → 0.162.193

package/src/repl/prompt-stash.js

@@ -0,0 +1,354 @@
+/**
+ * Durable prompt stash used by `/stash`.
+ *
+ * Prompts may contain private source code or credentials, so the state lives in
+ * the owner-only ChainlessChain state directory and is replaced atomically.
+ * Mutations share the normal cross-process file lock used by CLI state stores.
+ */
+import {
+  existsSync,
+  lstatSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { getStatePath } from "../lib/paths.js";
+import {
+  ensurePrivateDirectory,
+  ensurePrivateFile,
+  PRIVATE_FILE_MODE,
+} from "../lib/secure-fs.js";
+import { withFileLock } from "../lib/with-file-lock.js";
+
+export const PROMPT_STASH_SCHEMA = 1;
+export const MAX_STASH_ENTRIES = 50;
+export const MAX_STASH_PROMPT_CHARS = 100_000;
+export const MAX_STASH_FILE_BYTES = 32 * 1024 * 1024;
+
+export function getPromptStashPath() {
+  return join(getStatePath(), "prompt-stash-v1.json");
+}
+
+function emptyDocument() {
+  return { schema: PROMPT_STASH_SCHEMA, entries: [] };
+}
+
+function normalizePrompt(value) {
+  const text = String(value ?? "").replace(/\0/g, "");
+  if (!text.trim()) throw new Error("prompt stash requires non-empty text");
+  if (text.length > MAX_STASH_PROMPT_CHARS) {
+    throw new Error(
+      `prompt exceeds stash limit (${MAX_STASH_PROMPT_CHARS} characters)`,
+    );
+  }
+  return text;
+}
+
+function normalizeEntry(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  if (typeof entry.id !== "string" || typeof entry.text !== "string") {
+    return null;
+  }
+  if (!entry.text.trim() || entry.text.length > MAX_STASH_PROMPT_CHARS) {
+    return null;
+  }
+  return {
+    id: entry.id.slice(0, 100),
+    text: entry.text.replace(/\0/g, ""),
+    createdAt: Number.isFinite(Number(entry.createdAt))
+      ? Number(entry.createdAt)
+      : 0,
+  };
+}
+
+export class PromptStash {
+  constructor(options = {}) {
+    this.filePath = options.filePath || getPromptStashPath();
+    this.maxEntries = Math.max(
+      1,
+      Math.floor(Number(options.maxEntries) || MAX_STASH_ENTRIES),
+    );
+    this.now = options.now || Date.now;
+    this.uuid = options.uuid || randomUUID;
+    this.deps = {
+      existsSync,
+      lstatSync,
+      readFileSync,
+      renameSync,
+      rmSync,
+      writeFileSync,
+      ensurePrivateDirectory,
+      ensurePrivateFile,
+      withFileLock,
+      ...(options.deps || {}),
+    };
+  }
+
+  _assertReadablePath() {
+    if (!this.deps.existsSync(this.filePath)) return;
+    const stat = this.deps.lstatSync(this.filePath);
+    if (stat.isSymbolicLink()) {
+      const error = new Error("refusing prompt stash through a symbolic link");
+      error.code = "PROMPT_STASH_SYMLINK";
+      throw error;
+    }
+    if (Number(stat.size) > MAX_STASH_FILE_BYTES) {
+      const error = new Error(
+        `prompt stash exceeds ${MAX_STASH_FILE_BYTES} bytes`,
+      );
+      error.code = "PROMPT_STASH_TOO_LARGE";
+      throw error;
+    }
+    this.deps.ensurePrivateFile(this.filePath, {
+      applyWindowsAcl: true,
+      failIfUnavailable: true,
+    });
+  }
+
+  _read() {
+    this._assertReadablePath();
+    if (!this.deps.existsSync(this.filePath)) return emptyDocument();
+    let parsed;
+    try {
+      parsed = JSON.parse(this.deps.readFileSync(this.filePath, "utf8"));
+    } catch (cause) {
+      const error = new Error(`prompt stash is malformed: ${cause.message}`);
+      error.code = "PROMPT_STASH_CORRUPT";
+      error.cause = cause;
+      throw error;
+    }
+    if (
+      parsed?.schema !== PROMPT_STASH_SCHEMA ||
+      !Array.isArray(parsed.entries)
+    ) {
+      const error = new Error("prompt stash has an unsupported schema");
+      error.code = "PROMPT_STASH_SCHEMA";
+      throw error;
+    }
+    return {
+      schema: PROMPT_STASH_SCHEMA,
+      entries: parsed.entries
+        .map(normalizeEntry)
+        .filter(Boolean)
+        .slice(-this.maxEntries),
+    };
+  }
+
+  _write(document) {
+    const directory = dirname(this.filePath);
+    this.deps.ensurePrivateDirectory(directory, {
+      applyWindowsAcl: true,
+      failIfUnavailable: true,
+    });
+    const tempPath = `${this.filePath}.${process.pid}.${this.uuid().slice(0, 8)}.tmp`;
+    try {
+      this.deps.writeFileSync(
+        tempPath,
+        `${JSON.stringify(document, null, 2)}\n`,
+        { encoding: "utf8", mode: PRIVATE_FILE_MODE },
+      );
+      this.deps.ensurePrivateFile(tempPath, {
+        applyWindowsAcl: true,
+        failIfUnavailable: true,
+      });
+      this._renameWithRetry(tempPath);
+      this.deps.ensurePrivateFile(this.filePath, {
+        applyWindowsAcl: true,
+        failIfUnavailable: true,
+      });
+    } finally {
+      if (this.deps.existsSync(tempPath)) {
+        this.deps.rmSync(tempPath, { force: true });
+      }
+    }
+  }
+
+  _renameWithRetry(tempPath) {
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        this.deps.renameSync(tempPath, this.filePath);
+        return;
+      } catch (error) {
+        const transient = ["EACCES", "EBUSY", "EEXIST", "EPERM"].includes(
+          error?.code,
+        );
+        if (!transient || attempt >= 7) throw error;
+        try {
+          Atomics.wait(
+            new Int32Array(new SharedArrayBuffer(4)),
+            0,
+            0,
+            10 * (attempt + 1),
+          );
+        } catch {
+          // A runtime without Atomics.wait simply retries immediately.
+        }
+      }
+    }
+  }
+
+  _mutate(fn) {
+    this.deps.ensurePrivateDirectory(dirname(this.filePath), {
+      applyWindowsAcl: true,
+      failIfUnavailable: true,
+    });
+    return this.deps.withFileLock(
+      this.filePath,
+      () => {
+        const document = this._read();
+        const result = fn(document);
+        this._write(document);
+        return result;
+      },
+      { failIfUnavailable: true, timeoutMs: 5_000 },
+    );
+  }
+
+  stash(prompt) {
+    const text = normalizePrompt(prompt);
+    return this._mutate((document) => {
+      const createdAt = this.now();
+      const entry = {
+        id: `stash-${createdAt}-${this.uuid().slice(0, 8)}`,
+        text,
+        createdAt,
+      };
+      document.entries.push(entry);
+      if (document.entries.length > this.maxEntries) {
+        document.entries.splice(0, document.entries.length - this.maxEntries);
+      }
+      return entry;
+    });
+  }
+
+  list() {
+    return this._read().entries.slice().reverse();
+  }
+
+  pop() {
+    return this._mutate((document) => document.entries.pop() || null);
+  }
+
+  clear() {
+    return this._mutate((document) => {
+      const count = document.entries.length;
+      document.entries = [];
+      return count;
+    });
+  }
+}
+
+export function promptStashPreview(text, maxChars = 72) {
+  const flat = String(text || "")
+    .replace(/[\p{Cc}\p{Cf}]+/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  const limit = Math.max(20, Number(maxChars) || 72);
+  return flat.length > limit
+    ? `${flat.slice(0, Math.max(1, limit - 1))}…`
+    : flat;
+}
+
+export function renderPromptStash(entries, options = {}) {
+  const rows = Array.isArray(entries) ? entries : [];
+  if (!rows.length) return "Prompt stash is empty.";
+  const lines = ["Stashed prompts (newest first):"];
+  rows.forEach((entry, index) => {
+    let when = "unknown time";
+    if (entry.createdAt) {
+      const date = new Date(entry.createdAt);
+      if (!Number.isNaN(date.getTime())) {
+        when = date.toISOString().replace("T", " ").slice(0, 19);
+      }
+    }
+    lines.push(
+      `  ${index + 1}. ${promptStashPreview(entry.text, options.previewChars)} (${when})`,
+    );
+  });
+  return lines.join("\n");
+}
+
+/** Parse the text after `/stash`. */
+export function parsePromptStashCommand(args, currentPrompt = "") {
+  const raw = String(args || "");
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return String(currentPrompt || "").trim()
+      ? { action: "stash", prompt: String(currentPrompt) }
+      : { action: "help" };
+  }
+  const command = trimmed.split(/\s+/, 1)[0].toLowerCase();
+  if (command === "list" || command === "ls") return { action: "list" };
+  if (command === "pop") return { action: "pop" };
+  if (command === "clear") return { action: "clear" };
+  if (command === "add" || command === "push") {
+    const prompt = trimmed.slice(command.length).trim();
+    return prompt ? { action: "stash", prompt } : { action: "help" };
+  }
+  return { action: "stash", prompt: trimmed };
+}
+
+/**
+ * Execute a `/stash` operation. A popped prompt is returned, never submitted;
+ * the REPL wiring should place it back in the editable input buffer.
+ */
+export function runPromptStashCommand(args, options = {}) {
+  const stash = options.stash || new PromptStash(options);
+  const parsed = parsePromptStashCommand(args, options.currentPrompt);
+  switch (parsed.action) {
+    case "stash": {
+      const entry = stash.stash(parsed.prompt);
+      return {
+        ok: true,
+        action: "stash",
+        entry,
+        message: `Prompt stashed (${promptStashPreview(entry.text)}).`,
+      };
+    }
+    case "list": {
+      const entries = stash.list();
+      return {
+        ok: true,
+        action: "list",
+        entries,
+        message: renderPromptStash(entries),
+      };
+    }
+    case "pop": {
+      const entry = stash.pop();
+      return entry
+        ? {
+            ok: true,
+            action: "pop",
+            entry,
+            prompt: entry.text,
+            message: "Restored the newest stashed prompt for editing.",
+          }
+        : {
+            ok: false,
+            action: "pop",
+            prompt: null,
+            message: "Prompt stash is empty.",
+          };
+    }
+    case "clear": {
+      const count = stash.clear();
+      return {
+        ok: true,
+        action: "clear",
+        count,
+        message: `Cleared ${count} stashed prompt${count === 1 ? "" : "s"}.`,
+      };
+    }
+    default:
+      return {
+        ok: false,
+        action: "help",
+        message:
+          "Usage: /stash <prompt> | /stash list | /stash pop | /stash clear",
+      };
+  }
+}

package/src/repl/prompt-suggestions.js

@@ -0,0 +1,312 @@
+/**
+ * Non-blocking, provider-neutral prompt suggestions for the agent REPL.
+ *
+ * The controller accepts an injected `generate(context, { signal })` callback,
+ * so it can use whichever provider/runtime already owns the conversation. A
+ * small local heuristic is the no-provider fallback. Scheduling never blocks
+ * readline and a newer turn cancels an obsolete generation.
+ */
+
+const TRUE_VALUES = new Set(["1", "true", "yes", "on"]);
+const FALSE_VALUES = new Set(["0", "false", "no", "off"]);
+export const MAX_PROMPT_SUGGESTIONS = 3;
+export const MAX_SUGGESTION_CHARS = 180;
+
+function boolValue(value) {
+  if (typeof value === "boolean") return value;
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase();
+  if (TRUE_VALUES.has(normalized)) return true;
+  if (FALSE_VALUES.has(normalized)) return false;
+  return null;
+}
+
+/** Environment override > effective config > default. */
+export function resolvePromptSuggestionsEnabled(options = {}) {
+  const envValue = boolValue(
+    (options.env || process.env).CC_PROMPT_SUGGESTIONS,
+  );
+  if (envValue !== null) return envValue;
+  const config = options.config || {};
+  const configured = boolValue(
+    config.cli?.promptSuggestions ?? config.features?.promptSuggestions,
+  );
+  return configured ?? options.defaultEnabled ?? true;
+}
+
+function messageText(message) {
+  const content = message?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => (typeof part?.text === "string" ? part.text : ""))
+    .join(" ");
+}
+
+function lastAssistantText(context) {
+  if (typeof context?.lastAssistantText === "string") {
+    return context.lastAssistantText;
+  }
+  const messages = Array.isArray(context?.messages) ? context.messages : [];
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "assistant") {
+      return messageText(messages[index]);
+    }
+  }
+  return "";
+}
+
+/** Local fallback used when no model-backed generator is supplied. */
+export async function deriveLocalPromptSuggestions(context = {}) {
+  const text = lastAssistantText(context).toLowerCase();
+  const suggestions = [];
+  if (/\b(error|failed|failure|exception)\b|失败|报错|异常/.test(text)) {
+    suggestions.push("定位刚才失败的根因，修复后重新验证");
+  }
+  if (/\b(test|tests|tested|coverage)\b|测试|覆盖率/.test(text)) {
+    suggestions.push("运行相关测试并汇总仍需处理的问题");
+  }
+  if (
+    /\b(todo|remaining|next step|follow[- ]?up)\b|待办|剩余|下一步/.test(text)
+  ) {
+    suggestions.push("继续完成尚未处理的下一项，并给出验证结果");
+  }
+  if (/\b(diff|changed|modified|implementation)\b|变更|修改|实现/.test(text)) {
+    suggestions.push("审查最新变更，检查边界情况和回归风险");
+  }
+  if (!suggestions.length && text.trim()) {
+    suggestions.push("基于当前结果继续推进最合适的下一步");
+  }
+  return suggestions;
+}
+
+function splitSuggestionText(value) {
+  if (typeof value !== "string") return [];
+  return value
+    .split(/\r?\n/)
+    .map((line) => line.replace(/^\s*(?:[-*]|\d+[.)])\s*/, "").trim())
+    .filter(Boolean);
+}
+
+export function normalizePromptSuggestions(value, options = {}) {
+  const input = Array.isArray(value)
+    ? value
+    : Array.isArray(value?.suggestions)
+      ? value.suggestions
+      : splitSuggestionText(value);
+  const maxItems = Math.max(
+    1,
+    Number(options.maxItems) || MAX_PROMPT_SUGGESTIONS,
+  );
+  const maxChars = Math.max(
+    20,
+    Number(options.maxChars) || MAX_SUGGESTION_CHARS,
+  );
+  const seen = new Set();
+  const result = [];
+  for (const item of input) {
+    const candidate =
+      typeof item === "string"
+        ? item
+        : typeof item?.prompt === "string"
+          ? item.prompt
+          : typeof item?.text === "string"
+            ? item.text
+            : "";
+    const text = String(candidate)
+      .replace(/[\p{Cc}\p{Cf}]+/gu, " ")
+      .replace(/\s+/g, " ")
+      .trim();
+    if (!text) continue;
+    const bounded =
+      text.length > maxChars
+        ? `${text.slice(0, Math.max(1, maxChars - 1))}…`
+        : text;
+    const identity = bounded.toLowerCase();
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    result.push(bounded);
+    if (result.length >= maxItems) break;
+  }
+  return result;
+}
+
+export function renderPromptSuggestions(suggestions) {
+  const list = normalizePromptSuggestions(suggestions);
+  if (!list.length) return "No prompt suggestions available.";
+  return [
+    "Suggested next prompts:",
+    ...list.map((suggestion, index) => `  ${index + 1}. ${suggestion}`),
+  ].join("\n");
+}
+
+export class PromptSuggestionController {
+  constructor(options = {}) {
+    this.enabled = options.enabled !== false;
+    this.generate = options.generate || deriveLocalPromptSuggestions;
+    this.debounceMs = Math.max(0, Number(options.debounceMs) || 0);
+    this.onUpdate =
+      typeof options.onUpdate === "function" ? options.onUpdate : () => {};
+    this.setTimer = options.setTimer || setTimeout;
+    this.clearTimer = options.clearTimer || clearTimeout;
+    this.latest = [];
+    this.error = null;
+    this._generation = 0;
+    this._active = null;
+  }
+
+  _cancelActive(reason = "superseded") {
+    const active = this._active;
+    if (!active) return;
+    if (active.timer != null) this.clearTimer(active.timer);
+    active.controller.abort(reason);
+    active.resolve({ status: "cancelled", reason, suggestions: [] });
+    this._active = null;
+  }
+
+  setEnabled(enabled) {
+    this.enabled = enabled === true;
+    if (!this.enabled) {
+      this._cancelActive("disabled");
+      this.latest = [];
+      this.error = null;
+    }
+    return this.enabled;
+  }
+
+  schedule(context = {}) {
+    if (!this.enabled) {
+      return {
+        scheduled: false,
+        generation: this._generation,
+        promise: Promise.resolve({
+          status: "disabled",
+          suggestions: [],
+        }),
+      };
+    }
+    this._cancelActive();
+    const generation = ++this._generation;
+    const controller = new AbortController();
+    let resolvePromise;
+    const promise = new Promise((resolve) => {
+      resolvePromise = resolve;
+    });
+    const active = {
+      generation,
+      controller,
+      resolve: resolvePromise,
+      timer: null,
+      promise,
+    };
+    this._active = active;
+    active.timer = this.setTimer(async () => {
+      active.timer = null;
+      try {
+        const generated = await this.generate(context, {
+          signal: controller.signal,
+        });
+        if (controller.signal.aborted || this._active !== active) return;
+        const suggestions = normalizePromptSuggestions(generated);
+        this.latest = suggestions.slice();
+        this.error = null;
+        this._active = null;
+        resolvePromise({ status: "ready", suggestions: suggestions.slice() });
+        try {
+          this.onUpdate(suggestions.slice(), { generation });
+        } catch {
+          // Rendering callbacks cannot break suggestion lifecycle state.
+        }
+      } catch (error) {
+        if (controller.signal.aborted || this._active !== active) return;
+        this.error = error;
+        this._active = null;
+        resolvePromise({ status: "failed", error, suggestions: [] });
+      }
+    }, this.debounceMs);
+    return { scheduled: true, generation, promise };
+  }
+
+  status() {
+    return {
+      enabled: this.enabled,
+      generating: this._active !== null,
+      generation: this._generation,
+      suggestions: this.latest.slice(),
+      error: this.error ? "generation failed" : null,
+    };
+  }
+
+  dispose() {
+    this._cancelActive("disposed");
+  }
+}
+
+export function parsePromptSuggestionsCommand(args) {
+  const command = String(args || "")
+    .trim()
+    .toLowerCase();
+  if (!command || command === "status") return { action: "status" };
+  if (TRUE_VALUES.has(command)) return { action: "set", enabled: true };
+  if (FALSE_VALUES.has(command)) return { action: "set", enabled: false };
+  if (command === "refresh") return { action: "refresh" };
+  return { action: "help" };
+}
+
+export function runPromptSuggestionsCommand(args, options = {}) {
+  const controller = options.controller;
+  if (!controller) throw new Error("prompt suggestion controller is required");
+  const parsed = parsePromptSuggestionsCommand(args);
+  if (parsed.action === "set") {
+    try {
+      if (typeof options.persistEnabled === "function") {
+        options.persistEnabled(parsed.enabled);
+      }
+    } catch (error) {
+      return {
+        ok: false,
+        action: "set",
+        enabled: controller.status().enabled,
+        message: `Could not update prompt suggestions: ${error.message}`,
+      };
+    }
+    controller.setEnabled(parsed.enabled);
+    return {
+      ok: true,
+      action: "set",
+      enabled: parsed.enabled,
+      message: `Prompt suggestions ${parsed.enabled ? "enabled" : "disabled"}.`,
+    };
+  }
+  if (parsed.action === "refresh") {
+    const scheduled = controller.schedule(options.context || {});
+    return {
+      ok: scheduled.scheduled,
+      action: "refresh",
+      ...scheduled,
+      message: scheduled.scheduled
+        ? "Refreshing prompt suggestions in the background."
+        : "Prompt suggestions are disabled.",
+    };
+  }
+  if (parsed.action === "status") {
+    const status = controller.status();
+    return {
+      ok: true,
+      action: "status",
+      ...status,
+      message:
+        `Prompt suggestions: ${status.enabled ? "on" : "off"}` +
+        (status.generating ? " (generating)" : "") +
+        (status.suggestions.length
+          ? `\n${renderPromptSuggestions(status.suggestions)}`
+          : ""),
+    };
+  }
+  return {
+    ok: false,
+    action: "help",
+    message: "Usage: /suggestions on|off|status|refresh",
+  };
+}