@axhub/acp 0.1.0

package/dist/lib/acp2aisdk/commands.mjs

@@ -0,0 +1,121 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const SKILL_ROOTS = [
+    { scope: "user", relativePath: [".codex", "skills"] },
+    { scope: "system", relativePath: [".codex", "skills", ".system"] },
+];
+function normalizeText(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function normalizeSlashName(value) {
+    const normalized = normalizeText(value).replace(/^\/+/, "");
+    return normalized ? `/${normalized}` : "";
+}
+function uniqueCommands(commands) {
+    const seen = new Set();
+    return commands.filter((command) => {
+        const key = command.name.toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function parseFrontmatter(rawDocument) {
+    var _a, _b;
+    const normalized = rawDocument.replace(/^\uFEFF/, "");
+    if (!normalized.startsWith("---"))
+        return {};
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex < 0)
+        return {};
+    const frontmatter = normalized.slice(3, endIndex).trim();
+    const values = {};
+    for (const line of frontmatter.split(/\r?\n/)) {
+        const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!match)
+            continue;
+        const key = (_a = match[1]) === null || _a === void 0 ? void 0 : _a.trim();
+        if (!key)
+            continue;
+        values[key] = ((_b = match[2]) !== null && _b !== void 0 ? _b : "").trim().replace(/^["']|["']$/g, "");
+    }
+    return values;
+}
+function stripFrontmatter(rawDocument) {
+    const normalized = rawDocument.replace(/^\uFEFF/, "");
+    if (!normalized.startsWith("---"))
+        return normalized;
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex < 0)
+        return normalized;
+    return normalized.slice(endIndex + 4);
+}
+function inferDescription(rawDocument) {
+    const frontmatter = parseFrontmatter(rawDocument);
+    const explicit = normalizeText(frontmatter.description);
+    if (explicit)
+        return explicit;
+    const firstMeaningfulLine = stripFrontmatter(rawDocument)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line && !line.startsWith("---"));
+    return (firstMeaningfulLine === null || firstMeaningfulLine === void 0 ? void 0 : firstMeaningfulLine.replace(/^#+\s*/, "").trim()) || "Codex 技能";
+}
+async function readSkillCommand(skillPath, scope) {
+    try {
+        const rawDocument = await fs.readFile(path.join(skillPath, "SKILL.md"), "utf8");
+        const frontmatter = parseFrontmatter(rawDocument);
+        const name = normalizeSlashName(frontmatter.name || path.basename(skillPath));
+        if (!name)
+            return null;
+        return {
+            name,
+            description: inferDescription(rawDocument),
+            namespace: "skill",
+            source: "skill",
+            path: skillPath,
+            scope,
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+}
+async function listSkillDirectories(rootPath) {
+    let entries;
+    try {
+        entries = await fs.readdir(rootPath, { withFileTypes: true });
+    }
+    catch (_a) {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(rootPath, entry.name));
+}
+async function listSkillsFromRoot(rootPath, scope) {
+    const directories = await listSkillDirectories(rootPath);
+    const commands = await Promise.all(directories.map((directory) => readSkillCommand(directory, scope)));
+    return commands.filter((command) => Boolean(command));
+}
+export async function listAcpUiCommands({ workspacePath, } = {}) {
+    const normalizedWorkspacePath = normalizeText(workspacePath);
+    const roots = [
+        ...(normalizedWorkspacePath
+            ? [
+                {
+                    rootPath: path.join(normalizedWorkspacePath, ".codex", "skills"),
+                    scope: "project",
+                },
+            ]
+            : []),
+        ...SKILL_ROOTS.map((root) => ({
+            rootPath: path.join(os.homedir(), ...root.relativePath),
+            scope: root.scope,
+        })),
+    ];
+    const commandGroups = await Promise.all(roots.map((root) => listSkillsFromRoot(root.rootPath, root.scope)));
+    return uniqueCommands(commandGroups.flat()).sort((left, right) => left.name.localeCompare(right.name));
+}

package/dist/lib/acp2aisdk/config-options.d.ts

@@ -0,0 +1,3 @@
+import type { AcpCapabilitySnapshot, AcpProviderInstance, AcpRuntimeMetadata } from "./types";
+export declare function applyAcpConfigOption(provider: AcpProviderInstance, metadata: AcpRuntimeMetadata, key: keyof AcpCapabilitySnapshot["capabilities"], value: string | boolean, label: string): Promise<boolean>;
+export declare function applyAcpThoughtLevel(provider: AcpProviderInstance, metadata: AcpRuntimeMetadata): Promise<void>;

package/dist/lib/acp2aisdk/config-options.mjs

@@ -0,0 +1,86 @@
+import { buildAcpCapabilitySnapshot } from "./capabilities.mjs";
+function getLanguageModelInternals(provider) {
+    const model = provider.model;
+    if (!model || typeof model !== "object")
+        return null;
+    return model;
+}
+function resolveCapabilityConfigId(capability) {
+    var _a, _b;
+    if (!capability || capability.source === "fallback")
+        return null;
+    const configId = String((_a = capability === null || capability === void 0 ? void 0 : capability.configId) !== null && _a !== void 0 ? _a : "").trim();
+    if (configId)
+        return configId;
+    const key = String((_b = capability === null || capability === void 0 ? void 0 : capability.key) !== null && _b !== void 0 ? _b : "").trim();
+    return key || null;
+}
+function normalizeConfigOptionRequest({ sessionId, configId, value, }) {
+    if (typeof value === "boolean") {
+        return {
+            sessionId,
+            configId,
+            type: "boolean",
+            value,
+        };
+    }
+    return {
+        sessionId,
+        configId,
+        value,
+    };
+}
+function refreshCapabilitySnapshotFromConfigOptions({ metadata, model, sessionId, configOptions, }) {
+    var _a;
+    if (!Array.isArray(configOptions))
+        return;
+    model.sessionResponse = Object.assign(Object.assign({}, ((_a = model.sessionResponse) !== null && _a !== void 0 ? _a : {})), { sessionId,
+        configOptions });
+    metadata.capabilitySnapshot = buildAcpCapabilitySnapshot({
+        provider: metadata.provider,
+        sessionResponse: model.sessionResponse,
+    });
+}
+export async function applyAcpConfigOption(provider, metadata, key, value, label) {
+    var _a, _b;
+    const normalizedValue = typeof value === "boolean" ? value : String(value !== null && value !== void 0 ? value : "").trim();
+    if (normalizedValue === "")
+        return false;
+    const model = getLanguageModelInternals(provider);
+    const connection = model === null || model === void 0 ? void 0 : model.connection;
+    const sessionId = (_a = model === null || model === void 0 ? void 0 : model.sessionId) !== null && _a !== void 0 ? _a : provider.getSessionId();
+    const configId = resolveCapabilityConfigId((_b = metadata.capabilitySnapshot) === null || _b === void 0 ? void 0 : _b.capabilities[key]);
+    if (!(connection === null || connection === void 0 ? void 0 : connection.setSessionConfigOption) || !sessionId || !configId) {
+        return false;
+    }
+    if (!model)
+        return false;
+    try {
+        const response = await connection.setSessionConfigOption(Object.assign({}, normalizeConfigOptionRequest({
+            sessionId,
+            configId,
+            value: normalizedValue,
+        })));
+        refreshCapabilitySnapshotFromConfigOptions({
+            metadata,
+            model,
+            sessionId,
+            configOptions: response === null || response === void 0 ? void 0 : response.configOptions,
+        });
+        return true;
+    }
+    catch (error) {
+        metadata.warnings.push(`Failed to set ACP ${label} "${normalizedValue}": ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+export async function applyAcpThoughtLevel(provider, metadata) {
+    var _a;
+    const thoughtLevel = String((_a = metadata.thoughtLevel) !== null && _a !== void 0 ? _a : "").trim();
+    if (!thoughtLevel)
+        return;
+    const applied = await applyAcpConfigOption(provider, metadata, "thought_level", thoughtLevel, "thought level");
+    if (!applied) {
+        metadata.warnings.push(`ACP thought level "${thoughtLevel}" is selected, but this session does not expose a configurable thought_level option.`);
+    }
+}

package/dist/lib/acp2aisdk/context.d.ts

@@ -0,0 +1,88 @@
+export type ContextItemKind = "file" | "annotation";
+export type Rect = {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+export type TextRange = {
+    startLine?: number;
+    endLine?: number;
+    startColumn?: number;
+    endColumn?: number;
+    startOffset?: number;
+    endOffset?: number;
+};
+export type ContextFileItem = {
+    kind: "file";
+    id?: string;
+    path: string;
+    name?: string;
+    mimeType?: string;
+    range?: {
+        startLine?: number;
+        endLine?: number;
+        startColumn?: number;
+        endColumn?: number;
+    };
+    description?: string;
+    metadata?: Record<string, unknown>;
+};
+export type ContextAnnotationTarget = {
+    type: "web-element";
+    url?: string;
+    selector?: string;
+    elementId?: string;
+    label?: string;
+    rect?: Rect;
+} | {
+    type: "canvas-element";
+    filePath?: string;
+    canvasId?: string;
+    elementId?: string;
+    elementType?: string;
+    label?: string;
+    rect?: Rect;
+    link?: string;
+} | {
+    type: "text";
+    filePath?: string;
+    quote?: string;
+    range?: TextRange;
+    label?: string;
+};
+export type ContextAnnotationItem = {
+    kind: "annotation";
+    id?: string;
+    body: string;
+    target: ContextAnnotationTarget;
+    title?: string;
+    status?: "open" | "resolved";
+    source?: string;
+    metadata?: Record<string, unknown>;
+};
+export type ContextItem = ContextFileItem | ContextAnnotationItem;
+export type ContextBundleV2 = {
+    version: "2";
+    items: ContextItem[];
+    updatedAt: string;
+};
+export type ContextBundleChange = {
+    operation: "add" | "remove" | "replace" | "clear" | "consume";
+    ids?: string[];
+    kinds?: ContextItemKind[];
+    items?: ContextItem[];
+};
+export type ContextOperationResult = {
+    context: ContextBundleV2;
+    change: ContextBundleChange;
+};
+export declare function createContextBundle(items?: ContextItem[], updatedAt?: string): ContextBundleV2;
+export declare function isContextItemKind(value: unknown): value is ContextItemKind;
+export declare function filterContextBundle(context: ContextBundleV2, kinds?: ContextItemKind[]): ContextBundleV2;
+export declare function hasContextItems(context?: ContextBundleV2 | null): context is ContextBundleV2;
+export declare function formatDynamicContextPrompt(context: ContextBundleV2, userMessage: string): string;

package/dist/lib/acp2aisdk/context.mjs

@@ -0,0 +1,33 @@
+export function createContextBundle(items = [], updatedAt = new Date().toISOString()) {
+    return {
+        version: "2",
+        items,
+        updatedAt,
+    };
+}
+export function isContextItemKind(value) {
+    return value === "file" || value === "annotation";
+}
+export function filterContextBundle(context, kinds) {
+    if (!kinds)
+        return context;
+    const kindSet = new Set(kinds);
+    return Object.assign(Object.assign({}, context), { items: context.items.filter((item) => kindSet.has(item.kind)) });
+}
+export function hasContextItems(context) {
+    return ((context === null || context === void 0 ? void 0 : context.version) === "2" &&
+        Array.isArray(context.items) &&
+        context.items.length > 0);
+}
+export function formatDynamicContextPrompt(context, userMessage) {
+    const contextJson = JSON.stringify(context, null, 2).replaceAll("</", "<\\/");
+    return [
+        '<dynamic_context version="2">',
+        contextJson,
+        "</dynamic_context>",
+        "",
+        "<user_message>",
+        userMessage,
+        "</user_message>",
+    ].join("\n");
+}

package/dist/lib/acp2aisdk/default-capabilities.d.ts

@@ -0,0 +1,275 @@
+import type { AcpCapabilitySnapshot } from "./types";
+export declare const ACP_CAPABILITY_CACHE_TTL_MS: number;
+export declare const ACP_DEFAULT_CAPABILITY_SNAPSHOTS: {
+    claude: {
+        provider: "claude";
+        sessionId: null;
+        source: string;
+        updatedAt: string;
+        ttl: number;
+        agentVersion: null;
+        capabilities: {
+            model: {
+                key: "model";
+                currentValue: string;
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+            mode: {
+                key: "mode";
+                currentValue: "bypassPermissions";
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+            thought_level: {
+                key: "thought_level";
+                currentValue: string;
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+        };
+        metadata: {
+            availableCommands: never[];
+            tokenUsage: null;
+            rawSession: null;
+        };
+    };
+    codex: {
+        provider: "codex";
+        sessionId: null;
+        source: string;
+        updatedAt: string;
+        ttl: number;
+        agentVersion: null;
+        capabilities: {
+            model: {
+                key: "model";
+                currentValue: string;
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+            mode: {
+                key: "mode";
+                currentValue: "full-access";
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+            thought_level: {
+                key: "thought_level";
+                currentValue: string;
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+        };
+        metadata: {
+            availableCommands: never[];
+            tokenUsage: null;
+            rawSession: null;
+        };
+    };
+    gemini: {
+        provider: "gemini";
+        sessionId: null;
+        source: string;
+        updatedAt: string;
+        ttl: number;
+        agentVersion: null;
+        capabilities: {
+            model: {
+                key: "model";
+                currentValue: string;
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+            mode: {
+                key: "mode";
+                currentValue: "bypassPermissions";
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+            thought_level: {
+                key: "thought_level";
+                currentValue: string;
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+        };
+        metadata: {
+            availableCommands: never[];
+            tokenUsage: null;
+            rawSession: null;
+        };
+    };
+    opencode: {
+        provider: "opencode";
+        sessionId: null;
+        source: string;
+        updatedAt: string;
+        ttl: number;
+        agentVersion: null;
+        capabilities: {
+            model: {
+                key: "model";
+                currentValue: string;
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+            mode: {
+                key: "mode";
+                currentValue: "build";
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+            thought_level: {
+                key: "thought_level";
+                currentValue: string;
+                configId: string;
+                configKey: string;
+                source: "fallback";
+                options: {
+                    value: string;
+                    label: string;
+                    description: string;
+                    order: number;
+                }[];
+            };
+        };
+        metadata: {
+            availableCommands: never[];
+            tokenUsage: null;
+            rawSession: null;
+        };
+    };
+};
+export declare const CODEX_DEFAULT_CAPABILITY_SNAPSHOT: {
+    provider: "codex";
+    sessionId: null;
+    source: string;
+    updatedAt: string;
+    ttl: number;
+    agentVersion: null;
+    capabilities: {
+        model: {
+            key: "model";
+            currentValue: string;
+            configId: string;
+            configKey: string;
+            source: "fallback";
+            options: {
+                value: string;
+                label: string;
+                description: string;
+                order: number;
+            }[];
+        };
+        mode: {
+            key: "mode";
+            currentValue: "full-access";
+            configId: string;
+            configKey: string;
+            source: "fallback";
+            options: {
+                value: string;
+                label: string;
+                description: string;
+                order: number;
+            }[];
+        };
+        thought_level: {
+            key: "thought_level";
+            currentValue: string;
+            configId: string;
+            configKey: string;
+            source: "fallback";
+            options: {
+                value: string;
+                label: string;
+                description: string;
+                order: number;
+            }[];
+        };
+    };
+    metadata: {
+        availableCommands: never[];
+        tokenUsage: null;
+        rawSession: null;
+    };
+};
+export declare function getDefaultAcpCapabilitySnapshot(provider: string | null | undefined): AcpCapabilitySnapshot | null;