sidekick-shared 0.27.5 → 0.28.0

package/dist/esm/ensureDefaultAccounts.js

@@ -0,0 +1,62 @@
+import { reconcileClaudeAuthState } from './accounts';
+import { cleanupAbandonedLoginsAsync, syncLiveAccountState } from './accountSync';
+function logFailure(options, message, error) {
+    try {
+        options?.logger?.(message, error);
+    }
+    catch {
+        // Logging must never make account bootstrap fail.
+    }
+}
+function statusFromReport(report) {
+    if (report.registered)
+        return 'registered';
+    // A keyring-mode Codex login is a steady state sidekick cannot act on, not a failure.
+    if (report.skipped === 'keyring')
+        return 'skipped';
+    if (report.warnings.length > 0)
+        return 'error';
+    return 'skipped';
+}
+/**
+ * Host startup hook: run the one-time on-disk migrations, drop abandoned
+ * isolated logins, then reconcile the live logins with the saved profiles
+ * (registering any login sidekick has never seen).
+ */
+export async function ensureDefaultAccounts(options) {
+    try {
+        reconcileClaudeAuthState();
+    }
+    catch (error) {
+        logFailure(options, 'Claude auth reconciliation failed.', error);
+    }
+    try {
+        await cleanupAbandonedLoginsAsync();
+    }
+    catch (error) {
+        logFailure(options, 'Abandoned login cleanup failed.', error);
+    }
+    let sync;
+    try {
+        sync = await syncLiveAccountState({ reason: 'startup' });
+    }
+    catch (error) {
+        logFailure(options, 'Account sync failed.', error);
+        return { claude: 'error', codex: 'error' };
+    }
+    for (const [provider, report] of [
+        ['Claude', sync.claude],
+        ['Codex', sync.codex],
+    ]) {
+        if (report.skipped === 'keyring')
+            continue;
+        for (const warning of report.warnings) {
+            logFailure(options, `${provider} account sync: ${warning}`, undefined);
+        }
+    }
+    return {
+        claude: statusFromReport(sync.claude),
+        codex: statusFromReport(sync.codex),
+        sync,
+    };
+}

package/dist/esm/errorHistory.js

@@ -0,0 +1,56 @@
+import * as fs from 'fs';
+import { getGlobalDataPath } from './paths';
+import { updateJsonStoreAtomic } from './writers/atomic';
+export const ERROR_HISTORY_SCHEMA_VERSION = 1;
+export const MAX_ERROR_HISTORY_SESSIONS = 500;
+function emptyStore() {
+    return {
+        schemaVersion: ERROR_HISTORY_SCHEMA_VERSION,
+        sessions: [],
+        lastSaved: new Date().toISOString(),
+    };
+}
+export async function appendErrorHistory(identity, rollup, filePath = getGlobalDataPath('error-history.json')) {
+    const record = {
+        ...identity,
+        endedAt: identity.endedAt ?? new Date().toISOString(),
+        failures: rollup.byToolCategory,
+        retryAttempts: rollup.retryAttempts,
+        finishReasons: rollup.finishReasons,
+    };
+    await updateJsonStoreAtomic(filePath, emptyStore, (store) => ({
+        ...store,
+        schemaVersion: ERROR_HISTORY_SCHEMA_VERSION,
+        sessions: [...(Array.isArray(store.sessions) ? store.sessions : []), record].slice(-MAX_ERROR_HISTORY_SESSIONS),
+        lastSaved: record.endedAt,
+    }));
+    return record;
+}
+export async function readErrorHistory(filePath = getGlobalDataPath('error-history.json')) {
+    try {
+        const parsed = JSON.parse(await fs.promises.readFile(filePath, 'utf8'));
+        if (parsed.schemaVersion === ERROR_HISTORY_SCHEMA_VERSION && Array.isArray(parsed.sessions))
+            return parsed;
+    }
+    catch {
+        // Missing and malformed history are represented as an empty store.
+    }
+    return emptyStore();
+}
+export async function getTopFailingTools(days = 7, now = new Date(), filePath = getGlobalDataPath('error-history.json')) {
+    const cutoff = now.getTime() - Math.max(1, days) * 24 * 60 * 60 * 1000;
+    const store = await readErrorHistory(filePath);
+    const tools = new Map();
+    for (const session of store.sessions) {
+        const endedAt = Date.parse(session.endedAt);
+        if (!Number.isFinite(endedAt) || endedAt < cutoff)
+            continue;
+        for (const failure of session.failures) {
+            const item = tools.get(failure.tool) ?? { tool: failure.tool, failures: 0, categories: {} };
+            item.failures += failure.count;
+            item.categories[failure.category] = (item.categories[failure.category] ?? 0) + failure.count;
+            tools.set(failure.tool, item);
+        }
+    }
+    return Array.from(tools.values()).sort((left, right) => right.failures - left.failures);
+}

package/dist/esm/extractors/errorTaxonomy.js

@@ -0,0 +1,43 @@
+function stringifyError(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value == null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/** Classifies provider and tool failures into the stable shared taxonomy. */
+export function categorizeError(output, providerErrorType) {
+    const type = (providerErrorType ?? '').toLowerCase();
+    const text = `${type} ${stringifyError(output)}`.toLowerCase();
+    if (type === 'autherror' ||
+        /permission denied|not permitted|unauthori[sz]ed|forbidden|authentication|access denied/.test(text)) {
+        return 'permission';
+    }
+    if (/not found|no such file|enoent|does not exist|unknown command/.test(text))
+        return 'not_found';
+    if (/timeout|timed out|deadline exceeded|etimedout/.test(text))
+        return 'timeout';
+    if (/syntax error|parse error|invalid syntax/.test(text))
+        return 'syntax';
+    if (/exit[ _-]?code|non[- ]zero exit|process exited/.test(text))
+        return 'exit_code';
+    if (type === 'apierror' ||
+        type === 'outputlengtherror' ||
+        /tool_use_error|tool error|output length|rate limit|retry attempt/.test(text)) {
+        return 'tool_error';
+    }
+    return 'other';
+}
+/** Produces the compact error label used by the extension and CLI. */
+export function extractErrorMessage(content, toolName) {
+    let message = stringifyError(content) || 'Unknown error';
+    message = message.replace(/<\/?tool_use_error>/g, '').trim();
+    if (message.length > 150)
+        message = `${message.slice(0, 147)}...`;
+    return `${toolName}: ${message}`;
+}

package/dist/esm/extractors/gatherAssets.js

@@ -0,0 +1,32 @@
+/**
+ * Aggregate actionable assets for exactly one working directory.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/gatherAssets
+ */
+import { resolve } from 'node:path';
+import { readClaudeAssets } from './sources/claudeAssets';
+import { readCodexAssets } from './sources/codexAssets';
+import { byTimestampDesc, capped, dedupeAssets, dedupePlansByTitle, DEFAULT_CAPS, } from './sessionAssets';
+const ALL_AGENTS = ['claude', 'codex'];
+export function gatherAssetsForCwd(options = {}) {
+    const cwd = resolve(options.cwd || process.cwd());
+    const sessionLimit = options.sessionsPerAgent ?? 3;
+    const agents = options.agents ?? ALL_AGENTS;
+    const caps = { ...DEFAULT_CAPS, ...(options.caps || {}) };
+    const sources = [];
+    if (agents.includes('claude'))
+        sources.push(readClaudeAssets(cwd, sessionLimit));
+    if (agents.includes('codex'))
+        sources.push(readCodexAssets(cwd, sessionLimit));
+    const merge = (key, cap) => capped(dedupeAssets(sources.flatMap((source) => source[key]).sort(byTimestampDesc)), cap);
+    return {
+        urls: merge('urls', caps.url),
+        paths: merge('paths', caps.path),
+        commands: merge('commands', caps.command),
+        plans: capped(dedupePlansByTitle(sources.flatMap((source) => source.plans).sort(byTimestampDesc)), caps.plan),
+        inChat: sources.some((source) => source.hadSession),
+    };
+}

package/dist/esm/extractors/sessionAssets.js

@@ -0,0 +1,176 @@
+/**
+ * Extract actionable assets from agent session transcript text.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/sessionAssets
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import { isAbsolute, resolve } from 'node:path';
+const URL_RE = /(?:https?|file):\/\/[^\s"'<>)\]`\\]+/g;
+const PATH_RE = /(?:~|\.{0,2}\/)?[A-Za-z0-9_@.-]*(?:\/[A-Za-z0-9_@.-]+)+(?::\d+){0,2}|[A-Za-z0-9_@-]+\.[A-Za-z0-9]{1,8}(?::\d+){0,2}/g;
+const SHELL_TAGS = new Set([
+    'sh',
+    'bash',
+    'shell',
+    'zsh',
+    'console',
+    'shellscript',
+    'shell-session',
+]);
+export const DEFAULT_CAPS = {
+    command: 60,
+    path: 60,
+    url: 40,
+    plan: 25,
+};
+export function extractUrls(text) {
+    if (!text)
+        return [];
+    const urls = [];
+    for (const match of String(text).matchAll(URL_RE)) {
+        urls.push(match[0].replace(/[.,;:!?'"`]+$/, ''));
+    }
+    return urls;
+}
+export function extractFilePaths(text, cwd) {
+    if (!text)
+        return [];
+    const home = os.homedir();
+    const base = cwd ? resolve(cwd) : process.cwd();
+    const paths = [];
+    for (const match of String(text).matchAll(PATH_RE)) {
+        let token = match[0].replace(/[.,;:)>"]+$/, '');
+        let line;
+        const lineMatch = /^(.+?):(\d+)(?::\d+)?$/.exec(token);
+        if (lineMatch) {
+            token = lineMatch[1];
+            line = Number(lineMatch[2]);
+        }
+        let file = token.startsWith('~') ? token.replace(/^~/, home) : token;
+        if (!isAbsolute(file))
+            file = resolve(base, file);
+        if (isExistingFile(file)) {
+            paths.push(line !== undefined ? { file, line } : { file });
+        }
+    }
+    return paths;
+}
+export function extractCommands(text) {
+    if (!text)
+        return [];
+    const commands = [];
+    const source = String(text);
+    const fence = /```([\w.-]*)[ \t]*\r?\n([\s\S]*?)```/g;
+    const fencedSpans = [];
+    let match;
+    while ((match = fence.exec(source))) {
+        fencedSpans.push([match.index, fence.lastIndex]);
+        const shellTagged = SHELL_TAGS.has(match[1].toLowerCase());
+        let continuation = '';
+        for (const rawLine of match[2].split('\n')) {
+            const promptLine = /^\s*\$\s+(.+)$/.exec(rawLine);
+            if (promptLine) {
+                commands.push(promptLine[1].trim());
+                continue;
+            }
+            if (!shellTagged)
+                continue;
+            let line = rawLine.trim();
+            if (!line || line.startsWith('#'))
+                continue;
+            if (continuation) {
+                line = `${continuation} ${line}`;
+                continuation = '';
+            }
+            if (line.endsWith('\\')) {
+                continuation = line.slice(0, -1).trim();
+                continue;
+            }
+            commands.push(line);
+        }
+    }
+    for (const lineMatch of source.matchAll(/^[ \t]*\$[ \t]+(.+)$/gm)) {
+        const index = lineMatch.index ?? 0;
+        if (fencedSpans.some(([start, end]) => index >= start && index < end))
+            continue;
+        commands.push(lineMatch[1].trim());
+    }
+    return commands;
+}
+export function urlAsset(url, timestamp, provenance = {}) {
+    return { type: 'url', text: url, display: url, timestamp, ...provenance };
+}
+export function commandAsset(command, timestamp, provenance = {}) {
+    return { type: 'command', text: command, display: flat(command), timestamp, ...provenance };
+}
+export function pathAsset(path, timestamp, provenance = {}) {
+    const text = path.line !== undefined ? `${path.file}:${path.line}` : path.file;
+    return { type: 'path', text, display: text, timestamp, ...provenance };
+}
+export function planAsset(markdown, timestamp, provenance = {}) {
+    return { type: 'plan', text: markdown, display: planTitle(markdown), timestamp, ...provenance };
+}
+export function flat(value) {
+    return value.replace(/\s*\n\s*/g, ' ').trim();
+}
+export function planTitle(markdown) {
+    for (const rawLine of markdown.split('\n')) {
+        const line = rawLine.trim();
+        if (line)
+            return line.replace(/^#{1,6}\s*/, '');
+    }
+    return 'Plan';
+}
+export function isExistingFile(filePath) {
+    try {
+        return fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function readPlanFile(filePath) {
+    if (!filePath)
+        return undefined;
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+export function byTimestampDesc(a, b) {
+    return (b.timestamp || '').localeCompare(a.timestamp || '');
+}
+export function dedupeAssets(assets) {
+    const seen = new Set();
+    const deduped = [];
+    for (const asset of assets) {
+        if (!asset.text)
+            continue;
+        const key = `${asset.type}\0${asset.text}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(asset);
+    }
+    return deduped;
+}
+export function dedupePlansByTitle(plans) {
+    const seen = new Set();
+    const deduped = [];
+    for (const plan of plans) {
+        const key = (plan.display || plan.text).trim().toLowerCase();
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(plan);
+    }
+    return deduped;
+}
+export function capped(assets, cap) {
+    return cap > 0 ? assets.slice(0, cap) : assets;
+}

package/dist/esm/extractors/sources/claudeAssets.js

@@ -0,0 +1,158 @@
+/**
+ * Claude Code transcript reader for actionable asset extraction.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/sources/claudeAssets
+ */
+import { join } from 'node:path';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { getSessionDirectory } from '../../parsers/sessionPathResolver';
+import { commandAsset, extractCommands, extractFilePaths, extractUrls, isExistingFile, pathAsset, planAsset, readPlanFile, urlAsset, } from '../sessionAssets';
+const PATH_TOOLS = new Set(['Read', 'Write', 'Edit', 'NotebookEdit']);
+function dirExists(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function filesByMtimeDesc(dir, filter) {
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .filter(filter)
+        .map((name) => join(dir, name))
+        .map((filePath) => {
+        try {
+            return { path: filePath, mtime: statSync(filePath).mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((entry) => entry !== null)
+        .sort((a, b) => b.mtime - a.mtime)
+        .map((entry) => entry.path);
+}
+function readJsonl(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const lines = [];
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            lines.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Ignore partial or malformed JSONL lines.
+        }
+    }
+    return lines;
+}
+export function claudeSessions(cwd, limit = 3) {
+    const dir = getSessionDirectory(cwd);
+    if (!dirExists(dir))
+        return [];
+    return filesByMtimeDesc(dir, (name) => name.endsWith('.jsonl')).slice(0, limit);
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function provenance(sessionPath, source) {
+    return { agent: 'claude', sessionPath, source };
+}
+function addTextAssets(acc, text, cwd, timestamp, meta) {
+    for (const url of extractUrls(text))
+        acc.urls.push(urlAsset(url, timestamp, meta));
+    for (const filePath of extractFilePaths(text, cwd))
+        acc.paths.push(pathAsset(filePath, timestamp, meta));
+    for (const command of extractCommands(text))
+        acc.commands.push(commandAsset(command, timestamp, meta));
+}
+function addToolPathAssets(acc, value, cwd, timestamp, meta) {
+    for (const filePath of extractFilePaths(value, cwd)) {
+        acc.paths.push(pathAsset(filePath, timestamp, meta));
+    }
+}
+function accumClaude(filePath, cwd, acc) {
+    for (const line of readJsonl(filePath)) {
+        const timestamp = asString(line.timestamp);
+        if (line.type === 'attachment') {
+            const attachment = line.attachment;
+            const planFilePath = asString(attachment?.planFilePath);
+            if (planFilePath && isExistingFile(planFilePath)) {
+                const text = readPlanFile(planFilePath);
+                if (text?.trim())
+                    acc.plans.push(planAsset(text, timestamp, provenance(filePath, 'attachment:plan')));
+            }
+            continue;
+        }
+        const message = line.message;
+        const content = message?.content;
+        if (typeof content === 'string') {
+            addTextAssets(acc, content, cwd, timestamp, provenance(filePath, 'message'));
+            continue;
+        }
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            const typedBlock = block;
+            if (typedBlock.type === 'text') {
+                addTextAssets(acc, typedBlock.text, cwd, timestamp, provenance(filePath, 'message'));
+                continue;
+            }
+            if (typedBlock.type !== 'tool_use')
+                continue;
+            const name = asString(typedBlock.name);
+            const input = typedBlock.input || {};
+            const toolSource = name ? `tool:${name}` : 'tool';
+            const toolMeta = provenance(filePath, toolSource);
+            if (name === 'Bash') {
+                for (const url of extractUrls(input.command))
+                    acc.urls.push(urlAsset(url, timestamp, toolMeta));
+                addToolPathAssets(acc, input.command, cwd, timestamp, toolMeta);
+            }
+            else if (name && PATH_TOOLS.has(name)) {
+                addToolPathAssets(acc, input.file_path, cwd, timestamp, toolMeta);
+            }
+            else if (name === 'WebFetch' || name === 'WebSearch') {
+                for (const url of extractUrls(JSON.stringify(input)))
+                    acc.urls.push(urlAsset(url, timestamp, toolMeta));
+            }
+            else if (name === 'ExitPlanMode') {
+                const inline = asString(input.plan);
+                const markdown = inline?.trim() ? inline : readPlanFile(asString(input.planFilePath));
+                if (markdown?.trim())
+                    acc.plans.push(planAsset(markdown, timestamp, toolMeta));
+            }
+        }
+    }
+}
+export function readClaudeAssets(cwd, limit = 3) {
+    const sessions = claudeSessions(cwd, limit);
+    const acc = {
+        urls: [],
+        paths: [],
+        commands: [],
+        plans: [],
+        hadSession: sessions.length > 0,
+    };
+    for (const session of sessions)
+        accumClaude(session, cwd, acc);
+    return acc;
+}