shennian 0.2.6 → 0.2.7

package/dist/src/agents/model-registry/parsers.js

@@ -0,0 +1,349 @@
+// @arch docs/architecture/cli/model-discovery.md
+// @test src/__tests__/model-switching.test.ts
+export function stripAnsi(text) {
+    return text
+        .replace(/\u001b\[[0-9;?]*[a-zA-Z]/g, '') // eslint-disable-line no-control-regex
+        .replace(/\u001b\][^\u0007]*\u0007/g, '') // eslint-disable-line no-control-regex
+        .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, ''); // eslint-disable-line no-control-regex
+}
+function uniqueModels(models) {
+    const seen = new Set();
+    const unique = [];
+    for (const model of models) {
+        if (!model.id || seen.has(model.id))
+            continue;
+        seen.add(model.id);
+        unique.push(model);
+    }
+    return unique;
+}
+function titleCaseSegment(segment) {
+    if (!segment)
+        return segment;
+    return segment[0].toUpperCase() + segment.slice(1);
+}
+function prettifyCodexModel(id) {
+    return id
+        .split('-')
+        .map((segment) => {
+        if (segment === 'gpt')
+            return 'GPT';
+        if (segment === 'codex')
+            return 'Codex';
+        return /^\d/.test(segment) ? segment : titleCaseSegment(segment);
+    })
+        .join('-');
+}
+function prettifyReasoningEffort(id) {
+    switch (id) {
+        case 'low':
+            return 'Low';
+        case 'medium':
+            return 'Medium';
+        case 'high':
+            return 'High';
+        case 'xhigh':
+            return 'Extra High';
+        default:
+            return titleCaseSegment(id);
+    }
+}
+function prettifyCursorModel(id) {
+    return id
+        .split('-')
+        .map((segment) => (/^\d/.test(segment) ? segment : titleCaseSegment(segment)))
+        .join(' ');
+}
+function buildGeminiId(version, flavor, preview = false) {
+    const normalizedFlavor = flavor.toLowerCase().replace(/\s+/g, '-');
+    return `gemini-${version}-${normalizedFlavor}${preview ? '-preview' : ''}`;
+}
+export function parseCursorModels(raw) {
+    const models = [];
+    const clean = stripAnsi(raw);
+    for (const line of clean.split('\n')) {
+        const match = line.trim().match(/^(\S+)\s+-\s+(.+?)(?:\s+\(([^)]+)\))?$/);
+        if (!match)
+            continue;
+        const [, id, name, flags] = match;
+        const tags = flags?.split(',').map((flag) => flag.trim().toLowerCase()) ?? [];
+        models.push({
+            id,
+            name: name.trim() || prettifyCursorModel(id),
+            description: flags?.trim(),
+            isDefault: tags.includes('default') || tags.includes('current'),
+        });
+    }
+    return uniqueModels(models);
+}
+export function parseOpenClawModels(raw) {
+    try {
+        const data = JSON.parse(raw);
+        const models = (data.models ?? [])
+            .filter((model) => model.available)
+            .map((model) => ({
+            id: model.key,
+            name: model.name?.trim() || model.key,
+            provider: model.key.split('/')[0],
+            description: model.tags?.join(', '),
+            isDefault: model.tags?.includes('default') ?? false,
+        }));
+        return uniqueModels(models);
+    }
+    catch {
+        return [];
+    }
+}
+export function parseClaudeModels(raw) {
+    const rawClean = stripAnsi(raw).replace(/\s+/g, ' ');
+    const patterns = [
+        [/\d+\.Default\(recommended\).*?(?:Sonnet|currently\s*Sonnet)\s*([\d.]+)/i, 'default', 'Default (recommended)'],
+        [/\d+\.Sonnet.*?Sonnet\s*([\d.]+)/i, 'sonnet', 'Sonnet'],
+        [/\d+\.Opus.*?Opus\s*([\d.]+)/i, 'opus', 'Opus'],
+        [/\d+\.Haiku.*?Haiku\s*([\d.]+)/i, 'haiku', 'Haiku'],
+    ];
+    const models = [];
+    for (const [pattern, id, name] of patterns) {
+        const match = rawClean.match(pattern);
+        if (match) {
+            models.push({
+                id,
+                name,
+                description: `v${match[1]}`,
+                provider: 'anthropic',
+                isDefault: id === 'default',
+            });
+        }
+    }
+    if (models.length > 0)
+        return uniqueModels(models);
+    const fallback = [];
+    const defaultMatch = rawClean.match(/currently\s*(Sonnet|Opus|Haiku)\s*([34](?:\.\d)?)/i);
+    const aliasMap = { sonnet: 'sonnet', opus: 'opus', haiku: 'haiku' };
+    for (const match of rawClean.matchAll(/\b(Sonnet|Opus|Haiku)\s*([34](?:\.\d)?)\b/gi)) {
+        const family = (match[1] ?? '').toLowerCase();
+        const alias = aliasMap[family];
+        if (!alias)
+            continue;
+        const version = match[2] ?? '';
+        const isDefault = defaultMatch &&
+            defaultMatch[1]?.toLowerCase() === family &&
+            defaultMatch[2] === version;
+        fallback.push({
+            id: alias,
+            name: `${titleCaseSegment(family)} ${version}`,
+            provider: 'anthropic',
+            isDefault: Boolean(isDefault),
+        });
+    }
+    return uniqueModels(fallback);
+}
+function compareVersionNumbers(a, b) {
+    const length = Math.max(a.length, b.length);
+    for (let index = 0; index < length; index++) {
+        const left = a[index] ?? -1;
+        const right = b[index] ?? -1;
+        if (left === right)
+            continue;
+        return left - right;
+    }
+    return 0;
+}
+function extractClaudeFamilyVersion(id, family) {
+    const match = id.match(new RegExp(`^claude-${family}-([0-9]+(?:-[0-9]+)*)$`, 'i'));
+    if (!match?.[1])
+        return null;
+    const parts = match[1]
+        .split('-')
+        .map((part) => Number.parseInt(part, 10))
+        .filter((part) => Number.isFinite(part));
+    if (parts.length === 0 || parts.length > 2)
+        return null;
+    return parts;
+}
+function formatClaudeVersion(version) {
+    if (!version?.length)
+        return undefined;
+    return `v${version.join('.')}`;
+}
+export function parseClaudeBinaryModels(raw) {
+    const clean = stripAnsi(raw);
+    const aliasMap = {
+        default: 'Default (recommended)',
+        sonnet: 'Sonnet',
+        opus: 'Opus',
+        haiku: 'Haiku',
+    };
+    const familyVersions = new Map();
+    for (const family of ['sonnet', 'opus', 'haiku']) {
+        for (const match of clean.matchAll(new RegExp(`\\bclaude-${family}-[0-9.-]+\\b`, 'gi'))) {
+            const normalized = match[0].trim().toLowerCase().replace(/\./g, '-').replace(/-+$/g, '');
+            const version = extractClaudeFamilyVersion(normalized, family);
+            if (!version)
+                continue;
+            const current = familyVersions.get(family);
+            if (!current || compareVersionNumbers(current, version) < 0) {
+                familyVersions.set(family, version);
+            }
+        }
+    }
+    const models = [];
+    for (const alias of ['default', 'sonnet', 'opus', 'haiku']) {
+        if (!new RegExp(`\\b${alias}\\b`, 'i').test(clean))
+            continue;
+        const version = (alias === 'default' ? familyVersions.get('sonnet') : familyVersions.get(alias)) ?? null;
+        models.push({
+            id: alias,
+            name: aliasMap[alias],
+            description: formatClaudeVersion(version),
+            provider: 'anthropic',
+            isDefault: alias === 'default',
+        });
+    }
+    return uniqueModels(models);
+}
+export function fallbackClaudeAliasModels() {
+    return [
+        { id: 'default', name: 'Default (recommended)', provider: 'anthropic', isDefault: true },
+        { id: 'sonnet', name: 'Sonnet', provider: 'anthropic' },
+        { id: 'opus', name: 'Opus', provider: 'anthropic' },
+        { id: 'haiku', name: 'Haiku', provider: 'anthropic' },
+    ];
+}
+export function parseCodexModels(raw) {
+    const clean = stripAnsi(raw);
+    const models = [];
+    for (const line of clean.split('\n')) {
+        const match = line.match(/\b(gpt-[a-z0-9][a-z0-9.-]*)\b/i);
+        if (!match)
+            continue;
+        const id = match[1].trim();
+        const description = line.replace(id, '').replace(/^[^\w]+/, '').trim() || undefined;
+        models.push({
+            id,
+            name: prettifyCodexModel(id),
+            description,
+            provider: 'openai',
+            isDefault: /\bcurrent\b/i.test(line) || /\bselected\b/i.test(line),
+        });
+    }
+    return uniqueModels(models);
+}
+export function parseCodexAppServerModels(raw) {
+    const data = typeof raw === 'object' && raw !== null
+        ? raw
+        : {};
+    const currentModel = typeof data.config?.model === 'string' ? data.config.model : undefined;
+    const currentReasoningEffort = typeof data.config?.model_reasoning_effort === 'string'
+        ? data.config.model_reasoning_effort
+        : undefined;
+    const models = [];
+    for (const entry of data.data ?? []) {
+        if (typeof entry !== 'object' || entry === null)
+            continue;
+        const item = entry;
+        const id = typeof item.id === 'string'
+            ? item.id
+            : typeof item.model === 'string'
+                ? item.model
+                : '';
+        if (!id)
+            continue;
+        const displayName = typeof item.displayName === 'string'
+            ? item.displayName
+            : typeof item.name === 'string'
+                ? item.name
+                : undefined;
+        const description = typeof item.description === 'string' ? item.description : undefined;
+        const defaultReasoningEffort = typeof item.defaultReasoningEffort === 'string'
+            ? item.defaultReasoningEffort
+            : undefined;
+        const supportedReasoningEfforts = Array.isArray(item.supportedReasoningEfforts)
+            ? item.supportedReasoningEfforts
+                .map((effort) => {
+                if (typeof effort !== 'object' || effort === null)
+                    return null;
+                const rawEffort = effort;
+                const effortId = typeof rawEffort.reasoningEffort === 'string'
+                    ? rawEffort.reasoningEffort
+                    : typeof rawEffort.id === 'string'
+                        ? rawEffort.id
+                        : '';
+                if (!effortId)
+                    return null;
+                return {
+                    id: effortId,
+                    name: prettifyReasoningEffort(effortId),
+                    description: typeof rawEffort.description === 'string' ? rawEffort.description : undefined,
+                };
+            })
+                .filter((effort) => effort != null)
+            : undefined;
+        const additionalSpeedTiers = Array.isArray(item.additionalSpeedTiers)
+            ? item.additionalSpeedTiers.filter((tier) => typeof tier === 'string')
+            : undefined;
+        models.push({
+            id,
+            name: displayName || prettifyCodexModel(id),
+            description,
+            provider: 'openai',
+            isDefault: currentModel ? currentModel === id : item.isDefault === true,
+            supportedReasoningEfforts,
+            defaultReasoningEffort,
+            additionalSpeedTiers,
+        });
+    }
+    if (currentModel && !models.some((model) => model.id === currentModel)) {
+        models.unshift({
+            id: currentModel,
+            name: prettifyCodexModel(currentModel),
+            provider: 'openai',
+            isDefault: true,
+            defaultReasoningEffort: currentReasoningEffort,
+        });
+    }
+    return uniqueModels(models);
+}
+export function parseGeminiModels(raw) {
+    const clean = stripAnsi(raw);
+    const models = [];
+    for (const match of clean.matchAll(/\b(?:auto-)?gemini-[a-z0-9.-]+\b/gi)) {
+        const id = match[0].trim();
+        models.push({
+            id,
+            name: id,
+            provider: 'google',
+            isDefault: /\bcurrent\b/i.test(clean) && clean.includes(id),
+        });
+    }
+    for (const match of clean.matchAll(/\bGemini\s*(\d(?:\.\d)?)\s*(Pro|Flash(?:[- ]Lite)?)\s*(Preview)?\b/gi)) {
+        const version = match[1] ?? '';
+        const flavor = (match[2] ?? '').replace(/\s+/g, '-');
+        const preview = Boolean(match[3]);
+        const id = buildGeminiId(version, flavor, preview);
+        models.push({
+            id,
+            name: `Gemini ${version} ${flavor.replace(/-/g, ' ')}`.trim(),
+            provider: 'google',
+            isDefault: /\bcurrent\b/i.test(clean) && clean.includes(match[0] ?? ''),
+        });
+    }
+    for (const match of clean.matchAll(/\bAuto\s*Gemini\s*(\d(?:\.\d)?)\b/gi)) {
+        const version = match[1] ?? '';
+        const id = `auto-gemini-${version}`;
+        models.push({
+            id,
+            name: `Auto Gemini ${version}`,
+            provider: 'google',
+            isDefault: /\bcurrent\b/i.test(clean) && clean.includes(match[0] ?? ''),
+        });
+    }
+    return uniqueModels(models);
+}
+export function fallbackGeminiModels() {
+    return [
+        { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', provider: 'google', isDefault: true },
+        { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', provider: 'google' },
+        { id: 'auto-gemini-2.5', name: 'Auto Gemini 2.5', provider: 'google' },
+    ];
+}

package/dist/src/agents/model-registry/runner.d.ts

@@ -0,0 +1,6 @@
+import type { ResolvedCommandSpec } from '../command-spec.js';
+export declare function runResolvedCommand(spec: ResolvedCommandSpec, args: string[], timeoutMs?: number): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+}>;

package/dist/src/agents/model-registry/runner.js

@@ -0,0 +1,29 @@
+// @arch docs/architecture/cli/model-discovery.md
+// @test src/__tests__/model-switching.test.ts
+import { spawnResolvedCommand } from '../command-spec.js';
+import { DISCOVERY_WORKDIR } from './types.js';
+export function runResolvedCommand(spec, args, timeoutMs = 15_000) {
+    return new Promise((resolve, reject) => {
+        const proc = spawnResolvedCommand(spec, args, {
+            cwd: DISCOVERY_WORKDIR,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env, NO_COLOR: '1' },
+        });
+        let stdout = '';
+        let stderr = '';
+        const timer = setTimeout(() => {
+            proc.kill('SIGKILL');
+        }, timeoutMs);
+        proc.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        proc.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('error', reject);
+        proc.on('close', (exitCode) => {
+            clearTimeout(timer);
+            resolve({ stdout, stderr, exitCode });
+        });
+    });
+}

package/dist/src/agents/model-registry/service.d.ts

@@ -0,0 +1,6 @@
+import type { AgentInfo } from '@shennian/wire';
+import type { DetectedAgent } from '../detect.js';
+import type { DiscoveryContext } from './types.js';
+export declare function getCachedAgentInfos(detectedAgents: DetectedAgent[]): AgentInfo[];
+export declare function refreshAgentInfos(detectedAgents: DetectedAgent[], context: DiscoveryContext): Promise<AgentInfo[]>;
+export declare function resolveAgentInfos(detectedAgents: DetectedAgent[], context: DiscoveryContext): Promise<AgentInfo[]>;

package/dist/src/agents/model-registry/service.js

@@ -0,0 +1,71 @@
+// @arch docs/architecture/cli/model-discovery.md
+// @test src/__tests__/model-switching.test.ts
+import { isCacheFresh, readCache, writeCache } from './cache.js';
+import { discoverModelsForAgent } from './discovery.js';
+function uniqueModels(models) {
+    const seen = new Set();
+    const unique = [];
+    for (const model of models) {
+        if (!model.id || seen.has(model.id))
+            continue;
+        seen.add(model.id);
+        unique.push(model);
+    }
+    return unique;
+}
+export function getCachedAgentInfos(detectedAgents) {
+    const cache = readCache();
+    return detectedAgents.map((agent) => ({
+        type: agent.type,
+        models: cache.agents[agent.type]?.models ?? agent.models ?? [],
+    }));
+}
+export async function refreshAgentInfos(detectedAgents, context) {
+    const cache = readCache();
+    for (const agent of detectedAgents) {
+        delete cache.agents[agent.type];
+    }
+    writeCache(cache);
+    return resolveAgentInfos(detectedAgents, context);
+}
+export async function resolveAgentInfos(detectedAgents, context) {
+    const cache = readCache();
+    let changed = false;
+    const infos = [];
+    for (const agent of detectedAgents) {
+        const cached = cache.agents[agent.type];
+        let models;
+        if (isCacheFresh(cached, agent.version)) {
+            models = cached.models;
+        }
+        else {
+            let discovered = null;
+            try {
+                discovered = uniqueModels(await discoverModelsForAgent(agent, context));
+                models = discovered.length > 0 ? discovered : cached?.models ?? agent.models ?? [];
+            }
+            catch {
+                models = cached?.models ?? agent.models ?? [];
+            }
+            if (discovered && discovered.length > 0) {
+                const nextEntry = {
+                    version: agent.version,
+                    refreshedAt: Date.now(),
+                    models,
+                };
+                if (JSON.stringify(cached) !== JSON.stringify(nextEntry)) {
+                    cache.agents[agent.type] = nextEntry;
+                    changed = true;
+                }
+            }
+        }
+        infos.push({
+            type: agent.type,
+            models,
+        });
+    }
+    if (changed) {
+        writeCache(cache);
+    }
+    return infos;
+}

package/dist/src/agents/model-registry/types.d.ts

@@ -0,0 +1,30 @@
+import type { ModelInfo } from '@shennian/wire';
+export declare const CACHE_VERSION = 1;
+export declare const CACHE_TTL_MS: number;
+export declare const MODEL_CACHE_PATH: string;
+export declare const DISCOVERY_WORKDIR: string;
+export type CacheEntry = {
+    version?: string;
+    refreshedAt: number;
+    models: ModelInfo[];
+};
+export type CacheFile = {
+    version: number;
+    agents: Record<string, CacheEntry>;
+};
+export type DiscoveryContext = {
+    serverUrl?: string;
+    authToken?: string;
+};
+export type PtyOptions = {
+    startupArgs?: string[];
+    readyPatterns: RegExp[];
+    closePatterns: RegExp[];
+    preOpenPromptPatterns?: RegExp[];
+    preOpenPromptInput?: string;
+    initialDelayMs?: number;
+    timeoutMs?: number;
+    scrollAfterOpenMs?: number;
+    scrollCount?: number;
+    scrollIntervalMs?: number;
+};

package/dist/src/agents/model-registry/types.js

@@ -0,0 +1,8 @@
+// @arch docs/architecture/cli/model-discovery.md
+// @test src/__tests__/model-switching.test.ts
+import os from 'node:os';
+import { resolveShennianPath } from '../../config/index.js';
+export const CACHE_VERSION = 1;
+export const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+export const MODEL_CACHE_PATH = resolveShennianPath('model-cache.json');
+export const DISCOVERY_WORKDIR = os.tmpdir();

package/dist/src/agents/model-registry.d.ts

@@ -0,0 +1,13 @@
+export { getCachedAgentInfos, refreshAgentInfos, resolveAgentInfos } from './model-registry/service.js';
+import { parseClaudeBinaryModels, parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi } from './model-registry/parsers.js';
+/** Used by Vitest / `model-switching-e2e.ts` — not a stable public API. */
+export declare const modelSwitchingTestExports: {
+    readonly parseClaudeBinaryModels: typeof parseClaudeBinaryModels;
+    readonly parseClaudeModels: typeof parseClaudeModels;
+    readonly parseCodexModels: typeof parseCodexModels;
+    readonly parseCodexAppServerModels: typeof parseCodexAppServerModels;
+    readonly parseCursorModels: typeof parseCursorModels;
+    readonly parseOpenClawModels: typeof parseOpenClawModels;
+    readonly parseGeminiModels: typeof parseGeminiModels;
+    readonly stripAnsi: typeof stripAnsi;
+};

package/dist/src/agents/model-registry.js

@@ -0,0 +1,15 @@
+// @arch docs/architecture/cli/model-discovery.md
+// @test src/__tests__/model-switching.test.ts
+export { getCachedAgentInfos, refreshAgentInfos, resolveAgentInfos } from './model-registry/service.js';
+import { parseClaudeBinaryModels, parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi, } from './model-registry/parsers.js';
+/** Used by Vitest / `model-switching-e2e.ts` — not a stable public API. */
+export const modelSwitchingTestExports = {
+    parseClaudeBinaryModels,
+    parseClaudeModels,
+    parseCodexModels,
+    parseCodexAppServerModels,
+    parseCursorModels,
+    parseOpenClawModels,
+    parseGeminiModels,
+    stripAnsi,
+};

package/dist/src/agents/openclaw.d.ts

@@ -0,0 +1,20 @@
+import { AgentAdapter } from './adapter.js';
+export declare class OpenClawAdapter extends AgentAdapter {
+    readonly type: "openclaw";
+    private process;
+    private sessionId;
+    /** OpenClaw session id from JSON or `resume()`; falls back to app `sessionId`. */
+    private agentSessionId;
+    private currentModelId;
+    private workDir;
+    private seq;
+    private runId;
+    start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
+    send(text: string, modelId?: string): Promise<void>;
+    resume(agentSessionId: string): Promise<void>;
+    stop(): Promise<void>;
+    private spawnAgent;
+    private runAgentCommand;
+    private emitEvent;
+    private killProcess;
+}