gaoding-cli 1.0.0-alpha.10

package/dist/src/features/skill/installer.js

@@ -0,0 +1,265 @@
+import { randomUUID } from "node:crypto";
+import { cp, lstat, mkdir, mkdtemp, readFile, readlink, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, relative, resolve } from "node:path";
+export class SkillSyncError extends Error {
+    results;
+    constructor(message, results) {
+        super(message);
+        this.results = results;
+        this.name = "SkillSyncError";
+    }
+}
+export async function syncBundledSkills(skills, options = {}) {
+    const homeDirectory = options.homeDirectory ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const results = [];
+    for (const skill of skills) {
+        assertDescriptor(skill, results);
+        const targets = await skillTargets(skill.skill, homeDirectory, options.env ?? {});
+        const targetResults = [];
+        try {
+            const canonical = targets[0];
+            let current = await inspectTarget(canonical, skill, canonical.path, platform);
+            if (current.status === "conflict" || current.status === "broken") {
+                targetResults.push(current);
+                throw new Error(current.reason ?? "canonical Skill conflict");
+            }
+            if (current.status === "missing" || current.status === "outdated") {
+                await replaceManagedDirectory(skill, canonical.path, current.status === "outdated");
+                current = installed(canonical, "canonical", true);
+            }
+            targetResults.push(current);
+            for (const target of targets.slice(1)) {
+                current = await inspectTarget(target, skill, canonical.path, platform);
+                if (current.status === "conflict" || current.status === "broken") {
+                    targetResults.push(current);
+                    throw new Error(current.reason ?? "Agent host Skill conflict");
+                }
+                if (current.status === "missing") {
+                    current = await createLinkOrCopy(skill, target, canonical.path, {
+                        platform,
+                        createLink: options.createLink ?? symlink
+                    });
+                }
+                else if (current.status === "outdated") {
+                    await replaceManagedDirectory(skill, target.path, true);
+                    current = installed(target, "copy", true);
+                }
+                targetResults.push(current);
+            }
+            results.push(syncResult(skill, targetResults));
+        }
+        catch (error) {
+            const active = targets[targetResults.length];
+            if (active && !targetResults.some((target) => target.host === active.host)) {
+                targetResults.push({
+                    host: active.host,
+                    path: active.path,
+                    status: "conflict",
+                    changed: false,
+                    reason: message(error)
+                });
+            }
+            results.push(syncResult(skill, targetResults));
+            throw new SkillSyncError(`Agent Skill ${skill.skill} 同步失败${active ? ` (${active.path})` : ""}: ${message(error)}`, results);
+        }
+    }
+    return results;
+}
+export async function verifyBundledSkills(skills, options = {}) {
+    const homeDirectory = options.homeDirectory ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const results = [];
+    for (const skill of skills) {
+        assertDescriptor(skill, results);
+        const targets = await skillTargets(skill.skill, homeDirectory, options.env ?? {});
+        const canonical = targets[0];
+        const inspected = await Promise.all(targets.map((target) => inspectTarget(target, skill, canonical.path, platform)));
+        results.push(syncResult(skill, inspected));
+    }
+    const invalid = results.flatMap((result) => result.targets)
+        .find((target) => target.status !== "installed");
+    if (invalid) {
+        throw new SkillSyncError(`Agent Skill 验收失败 (${invalid.path}): ${invalid.reason ?? invalid.status}`, results);
+    }
+    return results;
+}
+async function skillTargets(skill, homeDirectory, env) {
+    const roots = [
+        { host: "claude-code", root: env.CLAUDE_HOME ?? join(homeDirectory, ".claude") },
+        { host: "codex", root: env.CODEX_HOME ?? join(homeDirectory, ".codex") },
+        { host: "cursor", root: env.CURSOR_HOME ?? join(homeDirectory, ".cursor") },
+        { host: "opencode", root: env.OPENCODE_HOME ?? join(homeDirectory, ".config", "opencode") },
+        { host: "openclaw", root: env.OPENCLAW_HOME ?? join(homeDirectory, ".openclaw") },
+        { host: "workbuddy", root: join(homeDirectory, ".workbuddy") }
+    ];
+    const detected = await Promise.all(roots.map(async (target) => ({
+        ...target,
+        detected: Boolean(await lstatMaybe(target.root))
+    })));
+    return [
+        { host: "canonical", path: join(homeDirectory, ".agents", "skills", skill) },
+        ...detected
+            .filter((target) => target.detected)
+            .map((target) => ({ host: target.host, path: join(target.root, "skills", skill) }))
+    ];
+}
+async function inspectTarget(target, skill, canonical, platform) {
+    const stat = await lstatMaybe(target.path);
+    if (!stat)
+        return targetResult(target, "missing");
+    if (target.host === "canonical") {
+        if (stat.isSymbolicLink()) {
+            return targetResult(target, "conflict", undefined, "canonical 不能是链接");
+        }
+        if (!stat.isDirectory()) {
+            return targetResult(target, "conflict", undefined, "canonical 路径不是目录");
+        }
+        const marker = await readMarker(target.path);
+        if (!marker || marker.skill !== skill.skill) {
+            return targetResult(target, "conflict", undefined, "canonical 缺少合法 marker");
+        }
+        return targetResult(target, marker.version === skill.version ? "installed" : "outdated", "canonical");
+    }
+    if (stat.isSymbolicLink()) {
+        let resolved;
+        try {
+            resolved = resolve(dirname(target.path), await readlink(target.path));
+        }
+        catch (error) {
+            return targetResult(target, "conflict", linkMode(platform), message(error));
+        }
+        if (!samePath(resolved, canonical, platform)) {
+            return targetResult(target, "conflict", linkMode(platform), "链接未指向 canonical Skill");
+        }
+        if (!await lstatMaybe(canonical)) {
+            return targetResult(target, "broken", linkMode(platform), "canonical Skill 不存在");
+        }
+        return targetResult(target, "installed", linkMode(platform));
+    }
+    if (!stat.isDirectory()) {
+        return targetResult(target, "conflict", undefined, "宿主路径不是目录或链接");
+    }
+    const marker = await readMarker(target.path);
+    if (!marker || marker.skill !== skill.skill) {
+        return targetResult(target, "conflict", undefined, "宿主目录缺少合法 marker");
+    }
+    return targetResult(target, marker.version === skill.version ? "installed" : "outdated", "copy");
+}
+async function createLinkOrCopy(skill, target, canonical, options) {
+    await mkdir(dirname(target.path), { recursive: true });
+    try {
+        if (options.platform === "win32") {
+            await options.createLink(canonical, target.path, "junction");
+            return installed(target, "junction", true);
+        }
+        await options.createLink(relative(dirname(target.path), canonical), target.path);
+        return installed(target, "symlink", true);
+    }
+    catch (error) {
+        if (await lstatMaybe(target.path))
+            throw error;
+        await replaceManagedDirectory(skill, target.path, false);
+        return installed(target, "copy", true);
+    }
+}
+async function replaceManagedDirectory(skill, destination, replace) {
+    const parent = dirname(destination);
+    await mkdir(parent, { recursive: true });
+    const stagingRoot = await mkdtemp(join(parent, ".gd-cli-stage-"));
+    const staged = join(stagingRoot, skill.skill);
+    let backup;
+    try {
+        await cp(skill.sourceDirectory, staged, { recursive: true });
+        await writeFile(join(staged, ".gd-cli.json"), `${JSON.stringify({ skill: skill.skill, version: skill.version })}\n`);
+        if (replace) {
+            backup = join(parent, `.gd-cli-backup-${randomUUID()}`);
+            await rename(destination, backup);
+        }
+        try {
+            await rename(staged, destination);
+        }
+        catch (error) {
+            if (backup)
+                await rename(backup, destination);
+            throw error;
+        }
+        if (backup)
+            await rm(backup, { recursive: true, force: false });
+    }
+    finally {
+        await rm(stagingRoot, { recursive: true, force: true });
+    }
+}
+async function readMarker(directory) {
+    try {
+        const parsed = JSON.parse(await readFile(join(directory, ".gd-cli.json"), "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const marker = parsed;
+        if (Object.keys(marker).sort().join(",") !== "skill,version")
+            return undefined;
+        if (typeof marker.skill !== "string" || !marker.skill.trim())
+            return undefined;
+        if (typeof marker.version !== "string" || !marker.version.trim())
+            return undefined;
+        return { skill: marker.skill, version: marker.version };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+async function lstatMaybe(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return undefined;
+        throw error;
+    }
+}
+function assertDescriptor(skill, results) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(skill.skill) || !skill.version.trim()) {
+        throw new SkillSyncError(`Agent Skill descriptor 无效: ${skill.skill}`, results);
+    }
+}
+function installed(target, mode, changed) {
+    return { host: target.host, path: target.path, status: "installed", mode, changed };
+}
+function targetResult(target, status, mode, reason) {
+    return {
+        host: target.host,
+        path: target.path,
+        status,
+        ...(mode ? { mode } : {}),
+        changed: false,
+        ...(reason ? { reason } : {})
+    };
+}
+function syncResult(skill, targets) {
+    return {
+        skill: skill.skill,
+        version: skill.version,
+        changed: targets.some((target) => target.changed),
+        targets
+    };
+}
+function linkMode(platform) {
+    return platform === "win32" ? "junction" : "symlink";
+}
+function samePath(left, right, platform) {
+    const normalizedLeft = resolve(left);
+    const normalizedRight = resolve(right);
+    return platform === "win32"
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/features/tool/catalog.js

@@ -0,0 +1,79 @@
+export class ToolInputError extends Error {
+    constructor() {
+        super("Tool 输入不可用。");
+        this.name = "ToolInputError";
+    }
+}
+const tools = [
+    {
+        name: "image.generate",
+        title: "图片生成与编辑",
+        description: "使用已发布的图片模型，根据文本和可选参考图片生成或编辑图片。"
+    },
+    {
+        name: "video.generate",
+        title: "视频生成",
+        description: "使用已发布的视频模型，根据文本及可选图片、视频或音频生成视频。"
+    },
+    {
+        name: "text.generate",
+        title: "文本生成",
+        description: "使用已发布的文本模型，根据文本和可选图片生成文本。"
+    }
+];
+function toolIndex(tool) {
+    return tools.findIndex((candidate) => candidate.name === tool);
+}
+function compareModels(left, right) {
+    return toolIndex(left.tool) - toolIndex(right.tool)
+        || left.sceneSort - right.sceneSort
+        || left.modelSort - right.modelSort
+        || (left.model < right.model ? -1 : left.model > right.model ? 1 : 0);
+}
+function summary(model) {
+    return {
+        tool: model.tool,
+        model: model.model,
+        title: model.title,
+        ...(model.description === undefined ? {} : { description: model.description }),
+        ...(model.cost === undefined ? {} : { cost: model.cost }),
+        ...(model.estimatedTime === undefined ? {} : { estimatedTime: model.estimatedTime })
+    };
+}
+export function projectToolList(catalog) {
+    return {
+        tools: tools.filter((tool) => catalog.models.some((model) => model.tool === tool.name))
+    };
+}
+export function projectModelList(catalog, tool) {
+    if (tool !== undefined && !catalog.models.some((model) => model.tool === tool)) {
+        throw new ToolInputError();
+    }
+    return {
+        models: catalog.models
+            .filter((model) => tool === undefined || model.tool === tool)
+            .toSorted(compareModels)
+            .map(summary)
+    };
+}
+export function projectModelDetail(catalog, model) {
+    const found = catalog.models.find((candidate) => candidate.model === model);
+    if (found === undefined)
+        throw new ToolInputError();
+    return {
+        ...summary(found),
+        ...(found.usageDescription === undefined
+            ? {}
+            : { usageDescription: found.usageDescription }),
+        ...(found.outputMediaTypes === undefined
+            ? {}
+            : { outputMediaTypes: found.outputMediaTypes }),
+        parameters: found.parameters
+    };
+}
+export function findToolModel(catalog, tool, model) {
+    const found = catalog.models.find((candidate) => candidate.tool === tool && candidate.model === model);
+    if (found === undefined)
+        throw new ToolInputError();
+    return found;
+}

package/dist/src/features/tool/dynamic-schema.js

@@ -0,0 +1,96 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import addFormatsImport, {} from "ajv-formats";
+import { ToolInputError } from "./catalog.js";
+function parameterSchema(parameter) {
+    const common = {
+        ...(parameter.description === undefined ? {} : { description: parameter.description }),
+        ...(parameter.default === undefined ? {} : { default: parameter.default })
+    };
+    if (parameter.type === "uri")
+        return { type: "string", format: "uri", ...common };
+    if (parameter.type === "uri[]") {
+        return { type: "array", items: { type: "string", format: "uri" }, ...common };
+    }
+    return {
+        type: "string",
+        ...(parameter.options === undefined
+            ? {}
+            : { enum: parameter.options.map((option) => option.value) }),
+        ...common
+    };
+}
+function sameShape(left, right) {
+    return left.type === right.type
+        && left.format === right.format
+        && left.items?.format === right.items?.format;
+}
+function mergeSchema(current, next) {
+    if (!sameShape(current, next)) {
+        const variants = current.anyOf ?? [current];
+        return variants.some((variant) => sameShape(variant, next))
+            ? current
+            : { anyOf: [...variants, next] };
+    }
+    if (current.enum === undefined || next.enum === undefined) {
+        if (current.enum === undefined)
+            return current;
+        const { enum: ignored, ...unrestricted } = current;
+        void ignored;
+        return unrestricted;
+    }
+    return {
+        ...current,
+        enum: [...new Set([...current.enum, ...next.enum])]
+    };
+}
+export function buildToolArgumentsSchema(catalog, tool) {
+    const models = catalog.models.filter((model) => model.tool === tool);
+    if (models.length === 0)
+        throw new ToolInputError();
+    const properties = {
+        model: {
+            type: "string",
+            description: "要调用的模型机器标识；取值来自 model list。"
+        }
+    };
+    for (const model of models) {
+        for (const parameter of model.parameters) {
+            const next = parameterSchema(parameter);
+            const current = properties[parameter.name];
+            properties[parameter.name] = current === undefined ? next : mergeSchema(current, next);
+        }
+    }
+    return {
+        type: "object",
+        properties,
+        required: ["model"],
+        additionalProperties: false
+    };
+}
+const ajv = new Ajv2020({ allErrors: true, strict: true });
+const addFormats = addFormatsImport;
+addFormats(ajv);
+function validator(model) {
+    const properties = {
+        model: { type: "string" }
+    };
+    for (const parameter of model.parameters) {
+        properties[parameter.name] = parameterSchema(parameter);
+    }
+    return ajv.compile({
+        type: "object",
+        properties,
+        required: [
+            "model",
+            ...model.parameters.filter((parameter) => parameter.required).map((parameter) => parameter.name)
+        ],
+        additionalProperties: false
+    });
+}
+export function assertModelArguments(model, value) {
+    if (typeof value !== "object" || value === null
+        || value.model !== model.model
+        || !validator(model)(value)) {
+        throw new ToolInputError();
+    }
+}