dsh-plan-completion 0.0.0-stage → 0.1.1

package/host/store.js

@@ -0,0 +1,312 @@
+/**
+ * host/store.js — 计划存储：内存实现（默认）+ 文件实现（预留、异步、原子写）。
+ *
+ * 设计依据：v1.2 §3.4（Host 私有存储域，key=sessionId，保留最近 5 版）、§3.5.2（CAS 提交）。
+ *
+ * 语义（两个 store 一致）：
+ *   get(sessionId)              → plan | null（返回副本，改它不影响存储）
+ *   put(plan, {cas})            → boolean；cas 省略=无条件写，null=仅新建，{gen,rev}=期望当前版本
+ *   history(sessionId)          → plan[]（旧 → 新，含当前版本）
+ *   prune(n = 5)                → 每会话只保留最近 n 版
+ *   clear(sessionId?)           → boolean | number
+ *   listSessions()              → sessionId[]
+ *
+ * createMemoryStore 同步；createFileStore 的方法全部为 async，但同样「永不 throw」：
+ * 出错时返回 null/false/[]，并把原因记录到 `store.lastError`（字符串）。
+ */
+
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { DEFAULTS } from './config.js';
+import { validVersion, versionEquals } from './plan.js';
+
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const isNonEmptyStr = (v) => typeof v === 'string' && v.trim().length > 0;
+
+function clone(value) {
+  if (value == null) return value;
+  try {
+    if (typeof structuredClone === 'function') return structuredClone(value);
+  } catch {
+    /* fall through */
+  }
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+
+function lightValidate(plan) {
+  if (!isObj(plan)) return false;
+  if (!isNonEmptyStr(plan.sessionId)) return false;
+  if (!validVersion(plan.version)) return false;
+  return true;
+}
+
+function casMatches(cas, state) {
+  const current = state && state.plan ? state.plan : null;
+  if (cas === undefined) return true;
+  if (cas === null) return current == null;
+  if (!validVersion(cas)) return false;
+  if (!current) return false;
+  return versionEquals(cas, current.version);
+}
+
+function pushHistory(state, plan) {
+  const last = state.history[state.history.length - 1];
+  if (last && versionEquals(last.version, plan.version)) {
+    state.history[state.history.length - 1] = clone(plan);
+  } else {
+    state.history.push(clone(plan));
+  }
+}
+
+/**
+ * 创建内存计划存储。
+ * @returns {object}
+ */
+export function createMemoryStore() {
+  /** @type {Map<string, {plan: object, history: object[]}>} */
+  const states = new Map();
+
+  function get(sessionId) {
+    if (!isNonEmptyStr(sessionId)) return null;
+    const state = states.get(sessionId);
+    return state && state.plan ? clone(state.plan) : null;
+  }
+
+  function put(plan, options = {}) {
+    if (!lightValidate(plan)) return false;
+    const cas = isObj(options) && Object.prototype.hasOwnProperty.call(options, 'cas') ? options.cas : undefined;
+    const sessionId = plan.sessionId;
+    const state = states.get(sessionId) ?? { plan: null, history: [] };
+    if (!casMatches(cas, state)) return false;
+    state.plan = clone(plan);
+    pushHistory(state, plan);
+    states.set(sessionId, state);
+    return true;
+  }
+
+  function history(sessionId) {
+    if (!isNonEmptyStr(sessionId)) return [];
+    const state = states.get(sessionId);
+    return state ? state.history.map((plan) => clone(plan)) : [];
+  }
+
+  function prune(n = DEFAULTS.keepVersions) {
+    const keep = Math.max(1, Math.floor(Number.isFinite(n) ? n : DEFAULTS.keepVersions));
+    let removed = 0;
+    let sessions = 0;
+    for (const state of states.values()) {
+      sessions += 1;
+      if (state.history.length > keep) {
+        removed += state.history.length - keep;
+        state.history = state.history.slice(-keep);
+      }
+    }
+    return { ok: true, removed, sessions, keep };
+  }
+
+  function clear(sessionId) {
+    if (sessionId === undefined) {
+      const count = states.size;
+      states.clear();
+      return count;
+    }
+    if (!isNonEmptyStr(sessionId)) return false;
+    return states.delete(sessionId);
+  }
+
+  function listSessions() {
+    return [...states.keys()];
+  }
+
+  return { get, put, history, prune, clear, listSessions, size: () => states.size };
+}
+
+/* ──────────────────────────────────────────────────────────────
+ * 文件存储（预留；运行时不强依赖）
+ * ────────────────────────────────────────────────────────────── */
+
+const BASE64URL_RE = /^[A-Za-z0-9_-]+$/;
+
+function encodeSessionId(sessionId) {
+  return Buffer.from(sessionId, 'utf8').toString('base64url');
+}
+
+function decodeSessionId(name) {
+  try {
+    return Buffer.from(name, 'base64url').toString('utf8');
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * 创建文件计划存储（异步）。每个会话一个 JSON 文件，写入走「tmp 文件 + rename」的原子替换。
+ *
+ * 说明：这是为 P2+ 预留的持久化接口，单进程假设、无跨进程锁；运行时不强依赖。
+ *
+ * @param {string} dir 存储目录（不存在会自动创建）
+ * @returns {object} 所有方法 async 且不 throw；出错返回 null/false/[] 并写 `lastError`
+ */
+export function createFileStore(dir) {
+  const enabled = isNonEmptyStr(dir);
+  const root = enabled ? dir.trim() : '';
+  const plansDir = enabled ? join(root, 'plans') : '';
+  let lastError = '';
+
+  const store = {
+    kind: 'file',
+    dir: root,
+    enabled,
+    get lastError() {
+      return lastError;
+    },
+    async get(sessionId) {
+      if (!enabled || !isNonEmptyStr(sessionId)) return null;
+      const data = await readState(sessionId);
+      return data && isObj(data.plan) ? clone(data.plan) : null;
+    },
+    async put(plan, options = {}) {
+      if (!enabled || !lightValidate(plan)) return false;
+      try {
+        const cas = isObj(options) && Object.prototype.hasOwnProperty.call(options, 'cas') ? options.cas : undefined;
+        const sessionId = plan.sessionId;
+        const data = (await readState(sessionId)) ?? { sessionId, plan: null, history: [] };
+        if (!casMatches(cas, data)) return false;
+        data.plan = clone(plan);
+        data.sessionId = sessionId;
+        if (!Array.isArray(data.history)) data.history = [];
+        const last = data.history[data.history.length - 1];
+        if (last && versionEquals(last.version, plan.version)) data.history[data.history.length - 1] = clone(plan);
+        else data.history.push(clone(plan));
+        await writeState(sessionId, data);
+        return true;
+      } catch (err) {
+        lastError = errText(err);
+        return false;
+      }
+    },
+    async history(sessionId) {
+      if (!enabled || !isNonEmptyStr(sessionId)) return [];
+      const data = await readState(sessionId);
+      return data && Array.isArray(data.history) ? data.history.map((plan) => clone(plan)) : [];
+    },
+    async prune(n = DEFAULTS.keepVersions) {
+      if (!enabled) return { ok: false, removed: 0, sessions: 0, keep: 0 };
+      const keep = Math.max(1, Math.floor(Number.isFinite(n) ? n : DEFAULTS.keepVersions));
+      let removed = 0;
+      let sessions = 0;
+      const ids = await listSessions();
+      for (const sessionId of ids) {
+        const data = await readState(sessionId);
+        if (!data || !Array.isArray(data.history)) continue;
+        sessions += 1;
+        if (data.history.length > keep) {
+          removed += data.history.length - keep;
+          data.history = data.history.slice(-keep);
+          await writeState(sessionId, data);
+        }
+      }
+      return { ok: true, removed, sessions, keep };
+    },
+    async clear(sessionId) {
+      if (!enabled) return false;
+      try {
+        if (sessionId === undefined) {
+          const ids = await listSessions();
+          let count = 0;
+          for (const id of ids) {
+            if (await removeState(id)) count += 1;
+          }
+          return count;
+        }
+        if (!isNonEmptyStr(sessionId)) return false;
+        return removeState(sessionId);
+      } catch (err) {
+        lastError = errText(err);
+        return false;
+      }
+    },
+    async listSessions() {
+      return listSessions();
+    },
+    async size() {
+      return (await listSessions()).length;
+    },
+  };
+
+  function errText(err) {
+    return err && typeof err.message === 'string' ? err.message : String(err);
+  }
+
+  function fileFor(sessionId) {
+    return join(plansDir, `${encodeSessionId(sessionId)}.json`);
+  }
+
+  async function readState(sessionId) {
+    if (!enabled || !isNonEmptyStr(sessionId)) return null;
+    try {
+      const raw = await readFile(fileFor(sessionId), 'utf8');
+      const data = JSON.parse(raw);
+      return isObj(data) ? data : null;
+    } catch (err) {
+      if (err && (err.code === 'ENOENT' || err.code === 'ENOTDIR')) return null;
+      lastError = errText(err);
+      return null;
+    }
+  }
+
+  async function writeState(sessionId, data) {
+    await mkdir(plansDir, { recursive: true });
+    const target = fileFor(sessionId);
+    const tmp = `${target}.${process.pid}.${randomUUID().replace(/-/g, '').slice(0, 12)}.tmp`;
+    try {
+      await writeFile(tmp, `${JSON.stringify(data)}\n`, 'utf8');
+      await rename(tmp, target);
+    } catch (err) {
+      try {
+        await rm(tmp, { force: true });
+      } catch {
+        /* ignore */
+      }
+      throw err;
+    }
+  }
+
+  async function removeState(sessionId) {
+    try {
+      await rm(fileFor(sessionId), { force: true });
+      return true;
+    } catch (err) {
+      lastError = errText(err);
+      return false;
+    }
+  }
+
+  async function listSessions() {
+    if (!enabled) return [];
+    try {
+      const names = await readdir(plansDir);
+      const ids = [];
+      for (const name of names) {
+        if (!name.endsWith('.json')) continue;
+        const base = name.slice(0, -5);
+        if (!BASE64URL_RE.test(base)) continue;
+        const sessionId = decodeSessionId(base);
+        if (sessionId) ids.push(sessionId);
+      }
+      return ids;
+    } catch (err) {
+      if (err && (err.code === 'ENOENT' || err.code === 'ENOTDIR')) return [];
+      lastError = errText(err);
+      return [];
+    }
+  }
+
+  return store;
+}

package/host/text.js

@@ -0,0 +1,168 @@
+/**
+ * host/text.js — 文本清洗与安全过滤工具（纯函数，零依赖）。
+ *
+ * 主要用途：
+ *  - suggestion 文本规范化：单行、去 Markdown、≤40 字、可直接发送；
+ *  - 危险建议过滤：明显破坏性命令一律拦掉（设计 §3.6 护栏 4、§3.8「危险建议过滤」）；
+ *  - 提问回合识别（启发式与证据共用）。
+ */
+
+import { DEFAULTS } from './config.js';
+
+/**
+ * 把任意值安全地转成字符串（只接受基础类型，对象/数组返回 ''）。
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function toText(value) {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  return '';
+}
+
+/**
+ * 按「字符（code point）」截断，不会切断 surrogate pair。
+ * @param {unknown} value
+ * @param {number} max
+ * @returns {string}
+ */
+export function clampChars(value, max) {
+  const text = toText(value);
+  const limit = Number.isFinite(max) ? Math.floor(max) : 0;
+  if (limit <= 0) return '';
+  const chars = Array.from(text);
+  return chars.length <= limit ? text : chars.slice(0, limit).join('');
+}
+
+/**
+ * 折叠为单行：换行/制表 → 空格，压缩连续空白，trim。
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function oneLine(value) {
+  return toText(value)
+    .replace(/[\r\n\t]+/g, ' ')
+    .replace(/\u00a0/g, ' ')
+    .replace(/\s{2,}/g, ' ')
+    .trim();
+}
+
+const MD_LINE_PREFIX = /^\s{0,3}(?:#{1,6}\s+|>\s*|[-*+]\s+|\d+[.)]\s+)/;
+const MD_INLINE = /(\*\*|__|\*|_|`)/g;
+const MD_LINK = /\[([^\]]*)\]\([^)]*\)/g;
+const WRAPPING_QUOTES = /^["'“”‘’「」『』]+|["'“”‘’「」『』]+$/g;
+
+/**
+ * 去掉常见 Markdown 痕迹，得到适合直接发送的纯文本。
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function stripMarkdown(value) {
+  let text = toText(value);
+  text = text.replace(/```[a-zA-Z0-9_+-]*/g, ' ');
+  text = text
+    .split(/\r?\n/)
+    .map((line) => line.replace(MD_LINE_PREFIX, ''))
+    .join(' ');
+  text = text.replace(MD_LINK, '$1');
+  text = text.replace(MD_INLINE, '');
+  return oneLine(text).replace(WRAPPING_QUOTES, '').trim();
+}
+
+/**
+ * 建议文本规范化：单行 + 去 Markdown + 截断到 max 字。
+ * @param {unknown} value
+ * @param {number} [max]
+ * @returns {string}
+ */
+export function clampSuggestion(value, max = DEFAULTS.suggestionMaxChars) {
+  return clampChars(stripMarkdown(value), max);
+}
+
+/**
+ * 明显破坏性命令形态（设计 §3.6 护栏 4、§3.8 危险建议过滤）。
+ * 只拦「明显」形态，避免误伤正常开发建议。
+ * @type {ReadonlyArray<{name: string, re: RegExp}>}
+ */
+export const DANGEROUS_PATTERNS = Object.freeze([
+  { name: 'rm-recursive-force', re: /(?:^|[\s;|&])rm\s+(?:-[a-zA-Z]*[rf][a-zA-Z]*\s+)+/ },
+  { name: 'windows-del-force', re: /\b(?:del|erase)\s+\/[fsq]/i },
+  { name: 'windows-rmdir-force', re: /\brmdir\s+\/s/i },
+  { name: 'format-drive', re: /\bformat\s+[a-z]:/i },
+  { name: 'mkfs', re: /\bmkfs(?:\.\w+)?\b/i },
+  { name: 'dd-write', re: /\bdd\s+if=/i },
+  { name: 'git-reset-hard', re: /\bgit\s+reset\s+--hard\b/i },
+  { name: 'git-clean-force', re: /\bgit\s+clean\s+-[a-z]*f/i },
+  { name: 'shutdown-reboot', re: /\b(?:shutdown|reboot)\b/i },
+  { name: 'drop-database', re: /\bdrop\s+(?:database|table)\b/i },
+  { name: 'curl-pipe-shell', re: /\b(?:curl|wget)\b[^\n|]*\|\s*(?:sudo\s+)?(?:ba|z|k|d)?sh\b/i },
+  { name: 'powershell-remove-recurse', re: /remove-item\b[^\n]*-recurse/i },
+  { name: 'powershell-encode', re: /powershell(?:\.exe)?\s+-(?:enc|encodedcommand)/i },
+  { name: 'invoke-expression', re: /\b(?:invoke-expression|iex)\b/i },
+  { name: 'fork-bomb', re: /:\(\)\s*\{/ },
+  { name: 'chmod-root', re: /chmod\s+-R\s+777\s+\//i },
+  { name: 'raw-device-write', re: />\s*\/dev\/(?:sd|nvme)/i },
+  { name: 'recursive-remove-item', re: /\b(?:Remove-Item|ri|rm)\b[^\n]*(?:-Recurse|-r)\b[^\n]*(?:\/|\*)/i },
+]);
+
+/**
+ * 检测文本里是否有明显破坏性命令形态。
+ * @param {unknown} value
+ * @returns {string|null} 命中的规则名，未命中返回 null
+ */
+export function findDangerousCommand(value) {
+  const text = oneLine(value);
+  if (!text) return null;
+  for (const item of DANGEROUS_PATTERNS) {
+    if (item.re.test(text)) return item.name;
+  }
+  return null;
+}
+
+/**
+ * suggestion 安全清洗：过滤危险形态、单行化、≤max 字。
+ * @param {unknown} value
+ * @param {number} [max]
+ * @returns {{ok: boolean, text: string, filtered: boolean, reason: string}}
+ */
+export function sanitizeSuggestion(value, max = DEFAULTS.suggestionMaxChars) {
+  if (typeof value !== 'string' || !value.trim()) {
+    return { ok: false, text: '', filtered: false, reason: 'empty' };
+  }
+  const danger = findDangerousCommand(value);
+  if (danger) return { ok: false, text: '', filtered: true, reason: `dangerous:${danger}` };
+  const text = clampSuggestion(value, max);
+  if (!text) return { ok: false, text: '', filtered: false, reason: 'empty' };
+  return { ok: true, text, filtered: false, reason: '' };
+}
+
+const QUESTION_TAIL = /(?:要不要|是否|选哪|哪个方案|需要我|可以吗|行不行|同意吗|还是说|你觉得|确认一下|要我|需要的话|好不好)/;
+
+/**
+ * 判断一段 assistant 文本是否是「向用户提问」的回合。
+ * 依据：末尾问号，或结尾一段出现典型提问句式。
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function looksLikeQuestion(value) {
+  const text = oneLine(value);
+  if (!text) return false;
+  if (/[?？]\s*$/.test(text)) return true;
+  const tail = Array.from(text).slice(-120).join('');
+  return QUESTION_TAIL.test(tail);
+}
+
+/**
+ * 安全取 JSON 字符串（解析异常返回 fallback），给需要稳定对比的地方用。
+ * @param {unknown} value
+ * @param {string} [fallback]
+ * @returns {string}
+ */
+export function stableJson(value, fallback = '') {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return fallback;
+  }
+}

package/icon.svg

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <rect x="2" y="2" width="60" height="60" rx="14" fill="#1d4ed8"/>
+  <rect x="12" y="14" width="26" height="4" rx="2" fill="#dbeafe"/>
+  <circle cx="16" cy="28" r="3.5" fill="#93c5fd"/>
+  <rect x="23" y="24.5" width="17" height="3.5" rx="1.75" fill="#e0ecff"/>
+  <circle cx="16" cy="40" r="3.5" fill="#93c5fd"/>
+  <rect x="23" y="36.5" width="14" height="3.5" rx="1.75" fill="#e0ecff"/>
+  <path d="M14 48.5h9" stroke="#93c5fd" stroke-width="3" stroke-linecap="round"/>
+  <path d="M41 43.5c-2.6 3.4-2 8 1.4 10.6 3.4 2.6 8 2 10.6-1.4l6-7.4-12-9.6z" fill="#fbbf24"/>
+  <path d="M45.5 38.8l7.2 5.8-3 3.7-7.2-5.8z" fill="#fde68a"/>
+</svg>