viberoom 0.3.0 → 0.4.0

package/vendor/acp/claude-agent-acp/dist/session-titles.js

@@ -0,0 +1,199 @@
+/**
+ * AI-generated session titles.
+ *
+ * Claude Code's own auto-title generation never runs under the Agent SDK — the
+ * latch that arms it is pre-set in the headless path — so `SDKSessionInfo.summary`
+ * degrades to the raw first prompt. This module asks the CLI for a real title
+ * instead, via the `generate_session_title` control request, and publishes it
+ * over ACP as a `session_info_update`.
+ *
+ * {@link SessionTitles} holds the per-session state and is owned by `Session`.
+ * `acp-agent.ts` drives it from four places: {@link SessionTitles.onPrompt} and
+ * {@link SessionTitles.onAssistantText} to collect text,
+ * {@link SessionTitles.onTurnEnd} at `session_state_changed: idle`, and
+ * {@link SessionTitles.reset} on `conversation_reset`.
+ */
+import { getSessionInfo } from "../../claude-agent-sdk/sdk.mjs";
+const MAX_TITLE_LENGTH = 256;
+/** How much session text the title is generated from. The CLI caps its own
+ *  title input at the same 1000 trailing characters. */
+const MAX_TITLE_CONTEXT_LENGTH = 1000;
+/** Below this the generator returns null without calling the model, so there is
+ *  nothing to gain by asking yet. */
+const MIN_TITLE_CONTEXT_LENGTH = 10;
+export function sanitizeTitle(text) {
+    // Replace newlines and collapse whitespace
+    const sanitized = text
+        .replace(/[\r\n]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (sanitized.length <= MAX_TITLE_LENGTH) {
+        return sanitized;
+    }
+    return sanitized.slice(0, MAX_TITLE_LENGTH - 1) + "…";
+}
+/** Rolling text a title is generated from: `previous` plus `text`, keeping only
+ *  the trailing {@link MAX_TITLE_CONTEXT_LENGTH} characters. */
+export function appendTitleContext(previous, text) {
+    const next = (previous ?? "") + text;
+    return next.length > MAX_TITLE_CONTEXT_LENGTH ? next.slice(-MAX_TITLE_CONTEXT_LENGTH) : next;
+}
+/** Whether this SDK still offers on-demand title generation. */
+function supportsTitleGeneration(query) {
+    return typeof query.generateSessionTitle === "function";
+}
+/** One session's title: the text a generated title is derived from, whether a
+ *  title has been settled on, and the last one published. Created with the
+ *  session and reachable as `session.titles`. */
+export class SessionTitles {
+    agent;
+    sessionId;
+    /** Last title pushed to the client via `session_info_update`, so an unchanged
+     *  title is never re-notified. Undefined until the first push. */
+    lastTitle;
+    /** Rolling tail of this session's own user + assistant text, capped at
+     *  {@link MAX_TITLE_CONTEXT_LENGTH}. Dropped once a title exists. */
+    context;
+    /** Set once this session has a title or has asked for one. A title is
+     *  generated at most once per session: the SDK reports a generated title in
+     *  the same field as a user `/rename`, so re-titling could silently overwrite
+     *  one. Released by {@link reset}, and when generation yields nothing. */
+    settled = false;
+    constructor(agent, sessionId) {
+        this.agent = agent;
+        this.sessionId = sessionId;
+    }
+    /** Collect a prompt's own text for the title, skipping openers not worth
+     *  titling after. No-op once the title is settled. */
+    onPrompt(prompt) {
+        if (this.settled) {
+            return;
+        }
+        const promptText = prompt
+            .flatMap((chunk) => (chunk.type === "text" ? [chunk.text] : []))
+            .join("\n");
+        this.context = appendTitleContext(this.context, `\n${promptText}\n`);
+    }
+    /** Collect the assistant's own answer for the title. Chunks are appended
+     *  verbatim so streamed text reassembles. No-op once the title is settled. */
+    onAssistantText(content) {
+        if (this.settled || content.type !== "text") {
+            return;
+        }
+        this.context = appendTitleContext(this.context, content.text);
+    }
+    /** Drop the title state so the next turn re-evaluates. Used on
+     *  `conversation_reset`, which mounts a fresh transcript. */
+    reset() {
+        this.settled = false;
+        this.context = undefined;
+        this.lastTitle = undefined;
+    }
+    /** Turn-end title handling. `idle` is the SDK's turn-over signal, so it is
+     *  when a title may have landed or become generatable.
+     *
+     *  `info.customTitle` is non-empty only once the session file holds a real
+     *  title — a user `/rename` or one generated earlier; the SDK folds both into
+     *  that one field. Adopt it and latch, so neither is ever titled over.
+     *
+     *  With no title yet, ask the SDK to generate one in the background: it is a
+     *  ~2s small-model call and turn-end must not wait on it. Only when that is
+     *  not possible do we fall back to `summary`, which for an SDK-driven session
+     *  is just the raw first prompt. */
+    async onTurnEnd(session) {
+        const info = await this.readSessionInfo(session);
+        if (info?.customTitle) {
+            this.settled = true;
+            this.context = undefined;
+            await this.publish(info.customTitle, info.lastModified);
+            return;
+        }
+        const fallback = info?.summary
+            ? { title: info.summary, lastModified: info.lastModified }
+            : undefined;
+        if (this.canRequest(session)) {
+            this.settled = true;
+            void this.requestGenerateTitle(session, fallback).catch((error) => {
+                this.agent.logger.error(`Session ${this.sessionId}: session title update failed: ${error}`);
+            });
+            return;
+        }
+        // Only while this session has no title of its own: `summary` degrades to the
+        // raw first prompt, which must never overwrite a generated title if the
+        // persisted one is slow to show up in `info`.
+        if (fallback && !this.settled) {
+            await this.publish(fallback.title, fallback.lastModified);
+        }
+    }
+    /** Read the SDK's stored info for this session. A missing session file or read
+     *  error is non-fatal: the title is best-effort and another turn will retry. */
+    async readSessionInfo(session) {
+        try {
+            return await getSessionInfo(this.sessionId, { dir: session.cwd });
+        }
+        catch (error) {
+            this.agent.logger.error(`Session ${this.sessionId}: failed to read session info: ${error}`);
+            return undefined;
+        }
+    }
+    /** Notify the client of a title, unless it is the one we last sent. */
+    async publish(rawTitle, lastModified) {
+        const title = sanitizeTitle(rawTitle);
+        if (title === this.lastTitle) {
+            return;
+        }
+        this.lastTitle = title;
+        await this.agent.client.sessionUpdate({
+            sessionId: this.sessionId,
+            update: {
+                sessionUpdate: "session_info_update",
+                title,
+                updatedAt: new Date(lastModified).toISOString(),
+            },
+        });
+    }
+    /** Whether to ask the SDK for a generated title now: once per session, on a
+     *  live query, with enough collected text for the generator to work with. */
+    canRequest(session) {
+        if (this.settled || session.queryClosed || session.cancelled) {
+            return false;
+        }
+        if (!supportsTitleGeneration(session.query)) {
+            return false;
+        }
+        return (this.context?.trim().length ?? 0) >= MIN_TITLE_CONTEXT_LENGTH;
+    }
+    /** Generate a title from the session's own text and publish it. `persist`
+     *  writes it to the session file, which is what carries it into
+     *  `session/list` and `session/load`. A null or failed generation releases the
+     *  latch so a later turn retries, and publishes `fallback` (the stored
+     *  summary) so a backend that can't generate titles is no worse off than
+     *  before. */
+    async requestGenerateTitle(session, fallback) {
+        const description = this.context?.trim() ?? "";
+        let title = null;
+        try {
+            title =
+                (await session.query.generateSessionTitle?.(description, {
+                    persist: true,
+                })) ?? null;
+        }
+        catch (error) {
+            this.agent.logger.error(`Session ${this.sessionId}: failed to generate a session title: ${error}`);
+        }
+        // A session torn down or replaced while the title was in flight must not
+        // adopt it.
+        if (this.agent.sessions[this.sessionId] !== session) {
+            return;
+        }
+        if (!title) {
+            this.settled = false;
+            if (fallback) {
+                await this.publish(fallback.title, fallback.lastModified);
+            }
+            return;
+        }
+        this.context = undefined;
+        await this.publish(title, Date.now());
+    }
+}

package/vendor/acp/claude-agent-acp/dist/settings.js

@@ -0,0 +1,185 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+// resolveSettings and filterEscalatingDefaultMode are marked @alpha in the
+// SDK; API may shift in a future release.
+import { filterEscalatingDefaultMode, resolveSettings, } from "../../claude-agent-sdk/sdk.mjs";
+import { CLAUDE_CONFIG_DIR } from "./acp-agent.js";
+/**
+ * Permission rule format examples:
+ * - "Read" - matches all Read tool calls
+ * - "Read(./.env)" - matches specific path
+ * - "Read(./.env.*)" - glob pattern
+ * - "Read(./secrets/**)" - recursive glob
+ * - "Bash(npm run lint)" - exact command prefix
+ * - "Bash(npm run:*)" - command prefix with wildcard
+ *
+ * Docs: https://code.claude.com/docs/en/iam#tool-specific-permission-rules
+ */
+function getManagedSettingsPath() {
+    switch (process.platform) {
+        case "darwin":
+            return "/Library/Application Support/ClaudeCode/managed-settings.json";
+        case "win32":
+            return "C:\\Program Files\\ClaudeCode\\managed-settings.json";
+        default:
+            return "/etc/claude-code/managed-settings.json";
+    }
+}
+/**
+ * Manages Claude Code settings using the SDK's `resolveSettings` merge engine
+ * so the values we see match what `query()` would observe.
+ *
+ * Watches the user/project/local/managed settings files for changes and
+ * re-resolves through the SDK on update. Escalating `permissions.defaultMode`
+ * values from repo-committed sources are filtered out via
+ * `filterEscalatingDefaultMode`, matching the CLI's trust policy.
+ */
+export class SettingsManager {
+    cwd;
+    effective = {};
+    watchers = [];
+    onChange;
+    logger;
+    initialized = false;
+    disposed = false;
+    debounceTimer = null;
+    initPromise = null;
+    constructor(cwd, options) {
+        this.cwd = cwd;
+        this.onChange = options?.onChange;
+        this.logger = options?.logger ?? console;
+    }
+    /**
+     * Initialize the settings manager by loading all settings and setting up file watchers
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.disposed = false;
+        this.initPromise = this.loadAllSettings().then(() => {
+            if (!this.disposed) {
+                this.setupWatchers();
+                this.initialized = true;
+            }
+            this.initPromise = null;
+        });
+        return this.initPromise;
+    }
+    /**
+     * Paths the SDK reads when resolving settings for this cwd. Watching the
+     * containing directories means we pick up file creation as well as edits.
+     */
+    getWatchedPaths() {
+        return [
+            path.join(CLAUDE_CONFIG_DIR, "settings.json"),
+            path.join(this.cwd, ".claude", "settings.json"),
+            path.join(this.cwd, ".claude", "settings.local.json"),
+            getManagedSettingsPath(),
+        ];
+    }
+    /**
+     * Resolves the effective settings via the SDK and applies the CLI's trust
+     * filter for escalating `permissions.defaultMode` values.
+     */
+    async loadAllSettings() {
+        try {
+            const resolved = await resolveSettings({ cwd: this.cwd });
+            this.effective = filterEscalatingDefaultMode(resolved);
+        }
+        catch (error) {
+            this.logger.error("Failed to resolve settings:", error);
+            this.effective = {};
+        }
+    }
+    /**
+     * Sets up file watchers for all settings files
+     */
+    setupWatchers() {
+        for (const filePath of this.getWatchedPaths()) {
+            try {
+                const dir = path.dirname(filePath);
+                const filename = path.basename(filePath);
+                if (fs.existsSync(dir)) {
+                    const watcher = fs.watch(dir, (eventType, changedFilename) => {
+                        if (changedFilename === filename) {
+                            this.handleSettingsChange();
+                        }
+                    });
+                    watcher.on("error", (error) => {
+                        this.logger.error(`Settings watcher error for ${filePath}:`, error);
+                    });
+                    this.watchers.push(watcher);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Failed to set up watcher for ${filePath}:`, error);
+            }
+        }
+    }
+    /**
+     * Handles settings file changes with debouncing to avoid rapid reloads
+     */
+    handleSettingsChange() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(async () => {
+            this.debounceTimer = null;
+            if (this.disposed) {
+                return;
+            }
+            try {
+                await this.loadAllSettings();
+                if (!this.disposed) {
+                    this.onChange?.();
+                }
+            }
+            catch (error) {
+                this.logger.error("Failed to reload settings:", error);
+            }
+        }, 100);
+    }
+    /**
+     * Returns the current merged settings
+     */
+    getSettings() {
+        return this.effective;
+    }
+    /**
+     * Returns the current working directory
+     */
+    getCwd() {
+        return this.cwd;
+    }
+    /**
+     * Updates the working directory and reloads project-specific settings
+     */
+    async setCwd(cwd) {
+        if (this.cwd === cwd) {
+            return;
+        }
+        this.dispose();
+        this.cwd = cwd;
+        await this.initialize();
+    }
+    /**
+     * Disposes of file watchers and cleans up resources
+     */
+    dispose() {
+        this.disposed = true;
+        this.initialized = false;
+        this.initPromise = null;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        for (const watcher of this.watchers) {
+            watcher.close();
+        }
+        this.watchers = [];
+    }
+}

package/vendor/acp/claude-agent-acp/dist/tool-result-meta.js

@@ -0,0 +1,19 @@
+/** Validate the SDK's currently untyped tool_result_meta sidecar. Unknown
+ * non-execution kinds are preserved so newer CLIs remain forward-compatible. */
+export function parseToolResultMeta(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    let byToolUseId;
+    for (const entry of raw) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const { id, non_execution_kind, user_feedback } = entry;
+        if (typeof id !== "string" || typeof non_execution_kind !== "string")
+            continue;
+        (byToolUseId ??= new Map()).set(id, {
+            nonExecutionKind: non_execution_kind,
+            ...(typeof user_feedback === "string" ? { userFeedback: user_feedback } : {}),
+        });
+    }
+    return byToolUseId;
+}