@openacp/cli 2026.328.2 → 2026.330.3

package/dist/chunk-UWH7KIAA.js

@@ -0,0 +1,701 @@
+import {
+  ContextManager,
+  EntireProvider
+} from "./chunk-MITTQMGZ.js";
+import {
+  DEFAULT_MAX_TOKENS,
+  TOKENS_PER_TURN_ESTIMATE
+} from "./chunk-APS6UEFU.js";
+
+// src/plugins/context/index.ts
+import * as os from "os";
+import * as path2 from "path";
+
+// src/plugins/context/history/history-context-builder.ts
+function selectLevel(turnCount) {
+  if (turnCount <= 10) return "full";
+  if (turnCount <= 25) return "balanced";
+  return "compact";
+}
+function estimateTokens(text) {
+  return Math.floor(text.length / 4);
+}
+function buildHistoryMarkdown(turns, mode) {
+  if (turns.length === 0) return "";
+  switch (mode) {
+    case "full":
+      return buildFull(turns);
+    case "balanced":
+      return buildBalanced(turns);
+    case "compact":
+      return buildCompact(turns);
+  }
+}
+function buildFull(turns) {
+  const out = [];
+  let userIndex = 0;
+  for (const turn of turns) {
+    if (turn.role === "user") {
+      userIndex++;
+      out.push(`**User [${userIndex}]:**`);
+      out.push(turn.content ?? "");
+      if (turn.attachments?.length) {
+        out.push(turn.attachments.map((a) => `[${a.type}: ${a.fileName}]`).join(" "));
+      }
+      out.push("");
+    } else if (turn.role === "assistant" && turn.steps?.length) {
+      out.push("**Assistant:**");
+      for (const step of turn.steps) {
+        out.push(renderStepFull(step));
+      }
+      if (turn.usage) {
+        const parts = [];
+        if (turn.usage.tokensUsed) parts.push(`${turn.usage.tokensUsed.toLocaleString()} tokens`);
+        if (turn.usage.cost) parts.push(`$${turn.usage.cost.amount.toFixed(4)}`);
+        if (parts.length) out.push(`**Usage**: ${parts.join(", ")}`);
+      }
+      out.push("");
+      out.push("---");
+      out.push("");
+    }
+  }
+  return out.join("\n");
+}
+function renderStepFull(step) {
+  switch (step.type) {
+    case "thinking":
+      return `> **Thinking**: ${step.content}
+`;
+    case "text":
+      return `${step.content}
+`;
+    case "tool_call":
+      return renderToolCallFull(step);
+    case "plan":
+      return renderPlan(step.entries);
+    case "image":
+      return `[Image: ${step.mimeType}]
+`;
+    case "audio":
+      return `[Audio: ${step.mimeType}]
+`;
+    case "resource":
+      return `[Resource: ${step.name}] ${step.uri}
+`;
+    case "resource_link":
+      return `[Resource Link: ${step.name}] ${step.uri}
+`;
+    case "mode_change":
+      return `*Mode changed to: ${step.modeId}*
+`;
+    case "config_change":
+      return `*Config ${step.configId} set to: ${step.value}*
+`;
+  }
+}
+function renderToolCallFull(step) {
+  const lines = [];
+  const loc = step.locations?.[0];
+  const locStr = loc ? loc.line ? `${loc.path}:${loc.line}` : loc.path : "";
+  if (step.diff) {
+    lines.push(`**[${step.name}]** \`${locStr || step.diff.path}\``);
+    lines.push("```diff");
+    if (step.diff.oldText) {
+      for (const line of step.diff.oldText.split("\n")) lines.push(`- ${line}`);
+    }
+    for (const line of step.diff.newText.split("\n")) lines.push(`+ ${line}`);
+    lines.push("```");
+  } else {
+    lines.push(`**[${step.name}]** \`${locStr}\``);
+  }
+  if (step.permission) {
+    lines.push(`*Permission: ${step.permission.outcome}*`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderPlan(entries) {
+  const lines = ["**Plan:**"];
+  for (const e of entries) {
+    const icon = e.status === "completed" || e.status === "done" ? "\u2705" : e.status === "in_progress" ? "\u{1F504}" : "\u2B1C";
+    lines.push(`${icon} ${e.content} (${e.priority})`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function buildBalanced(turns) {
+  const out = [];
+  let userIndex = 0;
+  for (const turn of turns) {
+    if (turn.role === "user") {
+      userIndex++;
+      out.push(`**User [${userIndex}]:**`);
+      out.push(turn.content ?? "");
+      out.push("");
+    } else if (turn.role === "assistant" && turn.steps?.length) {
+      out.push("**Assistant:**");
+      for (const step of turn.steps) {
+        if (step.type === "thinking") continue;
+        if (step.type === "text") {
+          out.push(step.content);
+        } else if (step.type === "tool_call") {
+          out.push(renderToolCallBalanced(step));
+        } else if (step.type === "plan") {
+          out.push(renderPlan(step.entries));
+        } else {
+          out.push(renderStepFull(step));
+        }
+      }
+      out.push("");
+      out.push("---");
+      out.push("");
+    }
+  }
+  return out.join("\n");
+}
+function renderToolCallBalanced(step) {
+  const loc = step.locations?.[0];
+  const locStr = loc ? loc.line ? `${loc.path}:${loc.line}` : loc.path : "";
+  if (step.diff) {
+    const oldLines = step.diff.oldText?.split("\n").length ?? 0;
+    const newLines = step.diff.newText.split("\n").length;
+    return `- ${step.name} \`${locStr || step.diff.path}\` (-${oldLines}/+${newLines} lines)`;
+  }
+  return `- ${step.name} \`${locStr}\``;
+}
+function buildCompact(turns) {
+  const out = [];
+  let i = 0;
+  while (i < turns.length) {
+    const turn = turns[i];
+    if (turn.role === "user") {
+      const userText = (turn.content ?? "").slice(0, 100);
+      const nextTurn = turns[i + 1];
+      if (nextTurn?.role === "assistant" && nextTurn.steps?.length) {
+        const tools = nextTurn.steps.filter((s) => s.type === "tool_call").map((s) => s.name);
+        const texts = nextTurn.steps.filter((s) => s.type === "text").map((s) => s.content.slice(0, 80));
+        const parts = [];
+        if (tools.length) parts.push(tools.join(", "));
+        if (texts.length) parts.push(texts.join(" "));
+        out.push(`User: ${userText} \u2192 Assistant: ${parts.join(" | ")}`);
+        i += 2;
+      } else {
+        out.push(`User: ${userText}`);
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  return out.join("\n");
+}
+
+// src/plugins/context/history/history-provider.ts
+var EMPTY_RESULT = {
+  markdown: "",
+  tokenEstimate: 0,
+  sessionCount: 0,
+  totalTurns: 0,
+  mode: "full",
+  truncated: false,
+  timeRange: { start: "", end: "" }
+};
+var HistoryProvider = class {
+  constructor(store, getSessionRecords) {
+    this.store = store;
+    this.getSessionRecords = getSessionRecords;
+  }
+  name = "local";
+  async isAvailable(_repoPath) {
+    return true;
+  }
+  async listSessions(query) {
+    if (!this.isSupportedType(query.type)) {
+      return { sessions: [], estimatedTokens: 0 };
+    }
+    const candidates = await this.resolveCandidates(query);
+    const sessions = [];
+    let estimatedTokens = 0;
+    for (const record of candidates) {
+      const history = await this.store.read(record.sessionId);
+      if (!history) continue;
+      const turnCount = history.turns.length;
+      const tokenEstimate = turnCount * TOKENS_PER_TURN_ESTIMATE;
+      sessions.push(this.toSessionInfo(record, turnCount));
+      estimatedTokens += tokenEstimate;
+    }
+    return { sessions, estimatedTokens };
+  }
+  async buildContext(query, options) {
+    if (!this.isSupportedType(query.type)) {
+      return { ...EMPTY_RESULT };
+    }
+    const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const candidates = await this.resolveCandidates(query, options?.limit);
+    const loaded = [];
+    for (const record of candidates) {
+      const history = await this.store.read(record.sessionId);
+      if (history) {
+        loaded.push({ record, history });
+      }
+    }
+    if (loaded.length === 0) {
+      return { ...EMPTY_RESULT };
+    }
+    const totalTurns = loaded.reduce((sum, s) => sum + s.history.turns.length, 0);
+    let mode = selectLevel(totalTurns);
+    let markdown = this.buildMergedMarkdown(loaded, mode, query);
+    let tokenEstimate = estimateTokens(markdown);
+    if (tokenEstimate > maxTokens && mode !== "compact") {
+      mode = "compact";
+      markdown = this.buildMergedMarkdown(loaded, mode, query);
+      tokenEstimate = estimateTokens(markdown);
+    }
+    let truncated = false;
+    let activeSessions = [...loaded];
+    while (tokenEstimate > maxTokens && activeSessions.length > 1) {
+      activeSessions = activeSessions.slice(0, activeSessions.length - 1);
+      markdown = this.buildMergedMarkdown(activeSessions, mode, query);
+      tokenEstimate = estimateTokens(markdown);
+      truncated = true;
+    }
+    const timeRange = this.computeTimeRange(activeSessions.map((s) => s.record));
+    return {
+      markdown,
+      tokenEstimate,
+      sessionCount: activeSessions.length,
+      totalTurns: activeSessions.reduce((sum, s) => sum + s.history.turns.length, 0),
+      mode,
+      truncated,
+      timeRange
+    };
+  }
+  // ─── Private helpers ─────────────────────────────────────────────────────────
+  isSupportedType(type) {
+    return type === "session" || type === "latest";
+  }
+  async resolveCandidates(query, limit) {
+    const all = this.getSessionRecords();
+    if (query.type === "session") {
+      const found = all.find((r) => r.sessionId === query.value);
+      return found ? [found] : [];
+    }
+    const n = limit ?? (parseInt(query.value, 10) || 5);
+    const sorted = [...all].sort(
+      (a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime()
+    );
+    return sorted.slice(0, n);
+  }
+  toSessionInfo(record, turnCount) {
+    return {
+      checkpointId: "",
+      sessionIndex: "",
+      transcriptPath: "",
+      createdAt: record.createdAt,
+      endedAt: record.lastActiveAt,
+      branch: "",
+      agent: record.agentName,
+      turnCount,
+      filesTouched: [],
+      sessionId: record.sessionId
+    };
+  }
+  buildMergedMarkdown(sessions, mode, query) {
+    if (sessions.length === 0) return "";
+    const totalTurns = sessions.reduce((sum, s) => sum + s.history.turns.length, 0);
+    const title = query.type === "session" ? query.value : `latest ${sessions.length} sessions`;
+    const parts = [];
+    parts.push(`# Conversation History \u2014 ${title}`);
+    parts.push(`${sessions.length} sessions | ${totalTurns} turns | mode: ${mode}`);
+    parts.push("");
+    for (let i = 0; i < sessions.length; i++) {
+      const { record, history } = sessions[i];
+      const sessionMd = buildHistoryMarkdown(history.turns, mode);
+      parts.push(`## Session ${i + 1} \u2014 ${record.agentName} \xB7 ${record.sessionId} (${history.turns.length} turns)`);
+      parts.push("");
+      if (sessionMd) {
+        parts.push(sessionMd);
+      }
+    }
+    parts.push(
+      "> **Note:** This conversation history may contain outdated information. Verify current state before acting on past context."
+    );
+    return parts.join("\n");
+  }
+  computeTimeRange(records) {
+    if (records.length === 0) return { start: "", end: "" };
+    const dates = records.map((r) => r.createdAt).filter(Boolean);
+    const ends = records.map((r) => r.lastActiveAt).filter(Boolean);
+    const start = dates.sort()[0] ?? "";
+    const end = ends.sort().reverse()[0] ?? "";
+    return { start, end };
+  }
+};
+
+// src/plugins/context/history/history-recorder.ts
+function toHistoryAttachment(att) {
+  return {
+    type: att.type,
+    fileName: att.fileName,
+    mimeType: att.mimeType,
+    size: att.size
+  };
+}
+function extractDiff(content) {
+  if (!Array.isArray(content)) return null;
+  for (const item of content) {
+    if (item && typeof item === "object" && item.type === "diff") {
+      const d = item;
+      if (typeof d.path === "string" && typeof d.newText === "string") {
+        const result = {
+          path: d.path,
+          newText: d.newText
+        };
+        if (typeof d.oldText === "string") result.oldText = d.oldText;
+        return result;
+      }
+    }
+  }
+  return null;
+}
+function extractLocations(locations) {
+  if (!Array.isArray(locations)) return void 0;
+  const result = [];
+  for (const loc of locations) {
+    if (loc && typeof loc === "object" && typeof loc.path === "string") {
+      const entry = { path: loc.path };
+      if (typeof loc.line === "number") entry.line = loc.line;
+      result.push(entry);
+    }
+  }
+  return result.length > 0 ? result : void 0;
+}
+var IGNORED_TYPES = /* @__PURE__ */ new Set([
+  "session_end",
+  "error",
+  "system_message",
+  "commands_update",
+  "session_info_update",
+  "model_update",
+  "user_message_chunk",
+  "tts_strip"
+]);
+var HistoryRecorder = class {
+  constructor(store) {
+    this.store = store;
+  }
+  states = /* @__PURE__ */ new Map();
+  onBeforePrompt(sessionId, text, attachments) {
+    let state = this.states.get(sessionId);
+    if (!state) {
+      state = {
+        history: { version: 1, sessionId, turns: [] },
+        currentAssistantTurn: null
+      };
+      this.states.set(sessionId, state);
+    }
+    const userTurn = {
+      index: state.history.turns.length,
+      role: "user",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: text
+    };
+    if (attachments && attachments.length > 0) {
+      userTurn.attachments = attachments.map(toHistoryAttachment);
+    }
+    state.history.turns.push(userTurn);
+    const assistantTurn = {
+      index: state.history.turns.length,
+      role: "assistant",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      steps: []
+    };
+    state.history.turns.push(assistantTurn);
+    state.currentAssistantTurn = assistantTurn;
+  }
+  onAfterEvent(sessionId, event) {
+    const state = this.states.get(sessionId);
+    if (!state || !state.currentAssistantTurn) return;
+    const turn = state.currentAssistantTurn;
+    const steps = turn.steps;
+    if (IGNORED_TYPES.has(event.type)) return;
+    switch (event.type) {
+      case "text": {
+        const last = steps[steps.length - 1];
+        if (last && last.type === "text") {
+          last.content += event.content;
+        } else {
+          steps.push({ type: "text", content: event.content });
+        }
+        break;
+      }
+      case "thought": {
+        const last = steps[steps.length - 1];
+        if (last && last.type === "thinking") {
+          last.content += event.content;
+        } else {
+          steps.push({ type: "thinking", content: event.content });
+        }
+        break;
+      }
+      case "tool_call": {
+        const step = {
+          type: "tool_call",
+          id: event.id,
+          name: event.name,
+          status: event.status
+        };
+        if (event.kind) step.kind = event.kind;
+        steps.push(step);
+        break;
+      }
+      case "tool_update": {
+        const existing = this.findToolCall(steps, event.id);
+        if (!existing) break;
+        existing.status = event.status;
+        if (event.rawInput !== void 0) existing.input = event.rawInput;
+        if (event.rawOutput !== void 0) existing.output = event.rawOutput;
+        if (event.content !== void 0) {
+          const diff = extractDiff(event.content);
+          if (diff) existing.diff = diff;
+        }
+        if (event.locations !== void 0) {
+          const locs = extractLocations(event.locations);
+          if (locs) existing.locations = locs;
+        }
+        break;
+      }
+      case "plan": {
+        steps.push({
+          type: "plan",
+          entries: event.entries.map((e) => ({
+            content: e.content,
+            priority: e.priority,
+            status: e.status
+          }))
+        });
+        break;
+      }
+      case "usage": {
+        turn.usage = {};
+        if (event.tokensUsed !== void 0) turn.usage.tokensUsed = event.tokensUsed;
+        if (event.contextSize !== void 0) turn.usage.contextSize = event.contextSize;
+        if (event.cost) turn.usage.cost = event.cost;
+        break;
+      }
+      case "image_content": {
+        steps.push({
+          type: "image",
+          mimeType: event.mimeType,
+          filePath: ""
+        });
+        break;
+      }
+      case "audio_content": {
+        steps.push({
+          type: "audio",
+          mimeType: event.mimeType,
+          filePath: ""
+        });
+        break;
+      }
+      case "resource_content": {
+        const step = {
+          type: "resource",
+          uri: event.uri,
+          name: event.name
+        };
+        if (event.text !== void 0) step.text = event.text;
+        steps.push(step);
+        break;
+      }
+      case "resource_link": {
+        const step = {
+          type: "resource_link",
+          uri: event.uri,
+          name: event.name
+        };
+        if (event.title !== void 0) step.title = event.title;
+        if (event.description !== void 0)
+          step.description = event.description;
+        steps.push(step);
+        break;
+      }
+      case "current_mode_update": {
+        steps.push({ type: "mode_change", modeId: event.modeId });
+        break;
+      }
+      case "config_option_update": {
+        for (const opt of event.options) {
+          steps.push({
+            type: "config_change",
+            configId: opt.id,
+            value: String(opt.currentValue)
+          });
+        }
+        break;
+      }
+    }
+  }
+  onPermissionResolved(sessionId, requestId, decision) {
+    const state = this.states.get(sessionId);
+    if (!state || !state.currentAssistantTurn) return;
+    const step = this.findToolCall(state.currentAssistantTurn.steps, requestId);
+    if (!step) return;
+    step.permission = { requested: true, outcome: decision };
+  }
+  async onTurnEnd(sessionId, stopReason) {
+    const state = this.states.get(sessionId);
+    if (!state || !state.currentAssistantTurn) return;
+    state.currentAssistantTurn.stopReason = stopReason;
+    state.currentAssistantTurn = null;
+    await this.store.write(state.history);
+  }
+  finalize(sessionId) {
+    this.states.delete(sessionId);
+  }
+  getState(sessionId) {
+    return this.states.get(sessionId);
+  }
+  findToolCall(steps, id) {
+    for (let i = steps.length - 1; i >= 0; i--) {
+      const s = steps[i];
+      if (s.type === "tool_call" && s.id === id) return s;
+    }
+    return void 0;
+  }
+};
+
+// src/plugins/context/history/history-store.ts
+import fs from "fs";
+import path from "path";
+var HistoryStore = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async write(history) {
+    await fs.promises.mkdir(this.dir, { recursive: true });
+    const filePath = this.filePath(history.sessionId);
+    await fs.promises.writeFile(filePath, JSON.stringify(history, null, 2));
+  }
+  async read(sessionId) {
+    const filePath = this.filePath(sessionId);
+    try {
+      const raw = await fs.promises.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async exists(sessionId) {
+    try {
+      await fs.promises.access(this.filePath(sessionId));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list() {
+    try {
+      const files = await fs.promises.readdir(this.dir);
+      return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+    } catch {
+      return [];
+    }
+  }
+  async delete(sessionId) {
+    try {
+      await fs.promises.unlink(this.filePath(sessionId));
+    } catch {
+    }
+  }
+  filePath(sessionId) {
+    return path.join(this.dir, `${sessionId}.json`);
+  }
+};
+
+// src/plugins/context/index.ts
+var contextPlugin = {
+  name: "@openacp/context",
+  version: "1.0.0",
+  description: "Conversation context management with pluggable providers",
+  essential: false,
+  permissions: ["services:register", "middleware:register", "kernel:access"],
+  async install(ctx) {
+    const { settings, terminal } = ctx;
+    await settings.setAll({ enabled: true });
+    terminal.log.success("Context defaults saved");
+  },
+  async configure(ctx) {
+    const { terminal, settings } = ctx;
+    const current = await settings.getAll();
+    const toggle = await terminal.confirm({
+      message: `Context service is ${current.enabled !== false ? "enabled" : "disabled"}. Toggle?`,
+      initialValue: false
+    });
+    if (toggle) {
+      const newState = current.enabled === false;
+      await settings.set("enabled", newState);
+      terminal.log.success(`Context service ${newState ? "enabled" : "disabled"}`);
+    }
+  },
+  async uninstall(ctx, opts) {
+    if (opts.purge) {
+      await ctx.settings.clear();
+      ctx.terminal.log.success("Context settings cleared");
+    }
+  },
+  async setup(ctx) {
+    const historyDir = path2.join(os.homedir(), ".openacp", "history");
+    const store = new HistoryStore(historyDir);
+    const recorder = new HistoryRecorder(store);
+    const sessionManager = ctx.sessions;
+    const getRecords = () => sessionManager.listRecords();
+    const manager = new ContextManager();
+    manager.register(new HistoryProvider(store, getRecords));
+    manager.register(new EntireProvider());
+    ctx.registerService("context", manager);
+    ctx.registerMiddleware("agent:beforePrompt", {
+      priority: 200,
+      handler: async (payload, next) => {
+        recorder.onBeforePrompt(payload.sessionId, payload.text, payload.attachments);
+        return next();
+      }
+    });
+    ctx.registerMiddleware("agent:afterEvent", {
+      priority: 200,
+      handler: async (payload, next) => {
+        recorder.onAfterEvent(payload.sessionId, payload.event);
+        return next();
+      }
+    });
+    ctx.registerMiddleware("turn:end", {
+      priority: 200,
+      handler: async (payload, next) => {
+        await recorder.onTurnEnd(payload.sessionId, payload.stopReason);
+        return next();
+      }
+    });
+    ctx.registerMiddleware("permission:afterResolve", {
+      priority: 200,
+      handler: async (payload, next) => {
+        recorder.onPermissionResolved(payload.sessionId, payload.requestId, payload.decision);
+        return next();
+      }
+    });
+    ctx.registerMiddleware("session:afterDestroy", {
+      priority: 200,
+      handler: async (payload, next) => {
+        recorder.finalize(payload.sessionId);
+        return next();
+      }
+    });
+    ctx.log.info("Context service ready (local history + entire providers)");
+  }
+};
+var context_default = contextPlugin;
+
+export {
+  context_default
+};
+//# sourceMappingURL=chunk-UWH7KIAA.js.map