gaoding-cli 1.0.0-alpha.5

package/dist/src/utils/agent-skill-installer.js

@@ -0,0 +1,389 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { findPackageRoot } from "../update/install-source.js";
+import { CLI_VERSION } from "./config.js";
+export class AgentSkillOperationError extends Error {
+    result;
+    constructor(message, result) {
+        super(message);
+        this.result = result;
+        this.name = "AgentSkillOperationError";
+    }
+}
+const SKILL_NAME = "gd-cli";
+const MARKER_FILE = ".gd-cli.json";
+const TARGET_IDS = [
+    "universal",
+    "claude-code",
+    "codex",
+    "cursor",
+    "opencode",
+    "openclaw",
+    "workbuddy",
+];
+export class AgentSkillInstaller {
+    homeDir;
+    env;
+    platform;
+    sourceDir;
+    constructor(options = {}) {
+        this.homeDir = options.homeDir ?? os.homedir();
+        this.env = options.env ?? process.env;
+        this.platform = options.platform ?? process.platform;
+        const packageRoot = options.packageRoot
+            ?? findPackageRoot(fileURLToPath(import.meta.url));
+        if (!packageRoot) {
+            throw new Error("无法定位 gaoding-cli package root");
+        }
+        this.sourceDir = path.join(packageRoot, "skills", SKILL_NAME);
+        const sourceSkill = path.join(this.sourceDir, "SKILL.md");
+        const sourceStat = lstat(sourceSkill);
+        if (!sourceStat?.isFile()) {
+            throw new Error(`Agent Skill source 不存在: ${sourceSkill}`);
+        }
+    }
+    listTargets() {
+        const home = this.homeDir;
+        return [
+            this.target("universal", "通用 Agent Skills", path.join(home, ".agents"), undefined),
+            this.target("claude-code", "Claude Code", this.env.CLAUDE_HOME || path.join(home, ".claude"), "claude"),
+            this.target("codex", "Codex", this.env.CODEX_HOME || path.join(home, ".codex"), "codex"),
+            this.target("cursor", "Cursor", this.env.CURSOR_HOME || path.join(home, ".cursor"), "cursor"),
+            this.target("opencode", "OpenCode", this.env.OPENCODE_HOME || path.join(home, ".config", "opencode"), "opencode"),
+            this.target("openclaw", "OpenClaw", this.env.OPENCLAW_HOME || path.join(home, ".openclaw"), "openclaw"),
+            this.target("workbuddy", "WorkBuddy", path.join(home, ".workbuddy"), "workbuddy"),
+        ];
+    }
+    detectedTargets() {
+        return this.listTargets()
+            .filter((target) => target.id !== "universal" && target.detected)
+            .map((target) => target.id);
+    }
+    status() {
+        return this.result(TARGET_IDS, new Set());
+    }
+    install(agents) {
+        const ids = uniqueTargets(["universal", ...agents]);
+        const targets = this.targets(ids);
+        const preflight = targets.map((target) => this.inspect(target));
+        const conflicts = preflight.filter((target) => target.status === "conflict");
+        if (conflicts.length > 0) {
+            throw new AgentSkillOperationError(conflictMessage("安装", conflicts), this.result(ids, new Set()));
+        }
+        const changed = new Set();
+        let active;
+        try {
+            const canonical = targets[0];
+            active = canonical;
+            const canonicalStatus = this.inspect(canonical);
+            if (canonicalStatus.status === "missing"
+                || canonicalStatus.status === "outdated") {
+                this.replaceManagedDirectory(canonical.path);
+                changed.add(canonical.id);
+            }
+            for (const target of targets.slice(1)) {
+                active = target;
+                const current = this.inspect(target);
+                if (current.status === "missing") {
+                    this.createLinkOrCopy(target);
+                    changed.add(target.id);
+                }
+                else if (current.status === "outdated" && current.mode === "copy") {
+                    this.replaceManagedDirectory(target.path);
+                    changed.add(target.id);
+                }
+            }
+            return this.result(ids, changed);
+        }
+        catch (error) {
+            if (error instanceof AgentSkillOperationError)
+                throw error;
+            throw this.ioError("安装 Agent Skill 失败", ids, changed, active, error);
+        }
+    }
+    update() {
+        const canonical = this.targetById("universal");
+        const canonicalStatus = this.inspect(canonical);
+        if (canonicalStatus.status !== "installed"
+            && canonicalStatus.status !== "outdated") {
+            throw new AgentSkillOperationError("canonical Skill 未安装或不是 gd-cli 托管，请先执行 gd-cli skills install", this.status());
+        }
+        const changed = new Set();
+        let active;
+        try {
+            active = canonical;
+            if (canonicalStatus.status === "outdated") {
+                this.replaceManagedDirectory(canonical.path);
+                changed.add(canonical.id);
+            }
+            for (const target of this.listTargets().slice(1)) {
+                active = target;
+                const current = this.inspect(target);
+                if (current.status === "outdated" && current.mode === "copy") {
+                    this.replaceManagedDirectory(target.path);
+                    changed.add(target.id);
+                }
+            }
+            return this.result(TARGET_IDS, changed);
+        }
+        catch (error) {
+            if (error instanceof AgentSkillOperationError)
+                throw error;
+            throw this.ioError("更新 Agent Skill 失败", TARGET_IDS, changed, active, error);
+        }
+    }
+    uninstall(agents) {
+        const ids = uniqueTargets(agents);
+        const targets = this.targets(ids);
+        const preflight = targets.map((target) => this.inspect(target));
+        const conflicts = preflight.filter((target) => target.status === "conflict");
+        if (conflicts.length > 0) {
+            throw new AgentSkillOperationError(conflictMessage("卸载", conflicts), this.result(ids, new Set()));
+        }
+        if (ids.includes("universal")) {
+            const selected = new Set(ids);
+            const blockers = this.listTargets()
+                .slice(1)
+                .map((target) => this.inspect(target))
+                .filter((target) => (target.status === "installed" || target.status === "outdated")
+                && !selected.has(target.agent));
+            if (blockers.length > 0) {
+                const resultIds = uniqueTargets([
+                    ...ids,
+                    ...blockers.map((target) => target.agent),
+                ]);
+                throw new AgentSkillOperationError(`不能卸载 universal：这些 Agent 仍依赖 canonical Skill：${blockers.map((item) => item.agent).join(", ")}`, this.result(resultIds, new Set()));
+            }
+        }
+        const changed = new Set();
+        const ordered = [
+            ...targets.filter((target) => target.id !== "universal"),
+            ...targets.filter((target) => target.id === "universal"),
+        ];
+        let active;
+        try {
+            for (const target of ordered) {
+                active = target;
+                const current = this.inspect(target);
+                if (current.status === "installed" || current.status === "outdated") {
+                    fs.rmSync(target.path, { recursive: true, force: false });
+                    changed.add(target.id);
+                }
+            }
+            return this.result(ids, changed);
+        }
+        catch (error) {
+            if (error instanceof AgentSkillOperationError)
+                throw error;
+            throw this.ioError("卸载 Agent Skill 失败", ids, changed, active, error);
+        }
+    }
+    target(id, name, root, executable) {
+        return {
+            id,
+            name,
+            path: path.join(root, "skills", SKILL_NAME),
+            detected: id === "universal"
+                || Boolean(lstat(root))
+                || Boolean(executable && hasExecutable(this.env.PATH, executable, this.platform)),
+        };
+    }
+    targetById(id) {
+        const target = this.listTargets().find((item) => item.id === id);
+        if (!target)
+            throw new Error(`不支持的 Agent target: ${id}`);
+        return target;
+    }
+    targets(ids) {
+        return ids.map((id) => this.targetById(id));
+    }
+    inspect(target) {
+        const stat = lstat(target.path);
+        if (!stat) {
+            return targetResult(target, "missing");
+        }
+        if (target.id === "universal") {
+            if (stat.isSymbolicLink()) {
+                return targetResult(target, "conflict", undefined, "canonical 不能是链接");
+            }
+            if (!stat.isDirectory()) {
+                return targetResult(target, "conflict", undefined, "canonical 路径不是目录");
+            }
+            const version = readMarkerVersion(target.path);
+            if (!version) {
+                return targetResult(target, "conflict", undefined, "canonical 缺少合法 .gd-cli.json");
+            }
+            return targetResult(target, version === CLI_VERSION ? "installed" : "outdated", "canonical");
+        }
+        if (stat.isSymbolicLink()) {
+            let resolved;
+            try {
+                const link = fs.readlinkSync(target.path);
+                resolved = path.resolve(path.dirname(target.path), link);
+            }
+            catch (error) {
+                return targetResult(target, "conflict", this.linkMode(), `无法读取链接: ${errorMessage(error)}`);
+            }
+            const canonical = this.targetById("universal").path;
+            if (!samePath(resolved, canonical, this.platform)) {
+                return targetResult(target, "conflict", this.linkMode(), "链接未指向 canonical Skill");
+            }
+            if (!lstat(canonical)) {
+                return targetResult(target, "broken", this.linkMode(), "链接指向 canonical Skill，但 canonical 不存在");
+            }
+            return targetResult(target, "installed", this.linkMode());
+        }
+        if (!stat.isDirectory()) {
+            return targetResult(target, "conflict", undefined, "target 路径不是目录或链接");
+        }
+        const version = readMarkerVersion(target.path);
+        if (!version) {
+            return targetResult(target, "conflict", undefined, "目录缺少合法 .gd-cli.json");
+        }
+        return targetResult(target, version === CLI_VERSION ? "installed" : "outdated", "copy");
+    }
+    result(ids, changedTargets, reasonOverrides = new Map()) {
+        const targets = this.targets(ids).map((target) => {
+            const inspected = this.inspect(target);
+            const reason = reasonOverrides.get(target.id) ?? inspected.reason;
+            return {
+                ...inspected,
+                changed: changedTargets.has(target.id),
+                ...(reason ? { reason } : {}),
+            };
+        });
+        const changed = targets.some((target) => target.changed);
+        return {
+            skill: "gd-cli",
+            version: CLI_VERSION,
+            canonical_path: this.targetById("universal").path,
+            changed,
+            restart_required: changed,
+            targets,
+        };
+    }
+    replaceManagedDirectory(destination) {
+        const parent = path.dirname(destination);
+        fs.mkdirSync(parent, { recursive: true });
+        const stagingRoot = fs.mkdtempSync(path.join(parent, ".gd-cli-stage-"));
+        const staged = path.join(stagingRoot, SKILL_NAME);
+        try {
+            fs.cpSync(this.sourceDir, staged, { recursive: true });
+            fs.writeFileSync(path.join(staged, MARKER_FILE), JSON.stringify({ version: CLI_VERSION }), "utf8");
+            if (lstat(destination)) {
+                fs.rmSync(destination, { recursive: true, force: false });
+            }
+            fs.renameSync(staged, destination);
+        }
+        finally {
+            fs.rmSync(stagingRoot, { recursive: true, force: true });
+        }
+    }
+    createLinkOrCopy(target) {
+        const canonical = this.targetById("universal").path;
+        fs.mkdirSync(path.dirname(target.path), { recursive: true });
+        try {
+            if (this.platform === "win32") {
+                fs.symlinkSync(canonical, target.path, "junction");
+            }
+            else {
+                const relative = path.relative(path.dirname(target.path), canonical);
+                fs.symlinkSync(relative, target.path);
+            }
+        }
+        catch (error) {
+            if (lstat(target.path))
+                throw error;
+            this.replaceManagedDirectory(target.path);
+        }
+    }
+    linkMode() {
+        return this.platform === "win32" ? "junction" : "symlink";
+    }
+    ioError(message, ids, changed, active, cause) {
+        const detail = errorMessage(cause);
+        const reasons = active
+            ? new Map([[active.id, detail]])
+            : new Map();
+        return new AgentSkillOperationError(`${message}${active ? ` (${active.path})` : ""}: ${detail}`, this.result(ids, changed, reasons));
+    }
+}
+function targetResult(target, status, mode, reason) {
+    return {
+        agent: target.id,
+        path: target.path,
+        status,
+        ...(mode ? { mode } : {}),
+        changed: false,
+        ...(reason ? { reason } : {}),
+    };
+}
+function uniqueTargets(ids) {
+    const unique = [];
+    for (const id of ids) {
+        if (!TARGET_IDS.includes(id)) {
+            throw new Error(`不支持的 Agent target: ${String(id)}`);
+        }
+        if (!unique.includes(id))
+            unique.push(id);
+    }
+    return unique;
+}
+function readMarkerVersion(directory) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(directory, MARKER_FILE), "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return undefined;
+        }
+        const marker = parsed;
+        if (Object.keys(marker).length !== 1)
+            return undefined;
+        if (typeof marker.version !== "string" || !marker.version.trim()) {
+            return undefined;
+        }
+        return marker.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+function lstat(file) {
+    try {
+        return fs.lstatSync(file);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return undefined;
+        throw error;
+    }
+}
+function samePath(left, right, platform) {
+    const normalizedLeft = path.resolve(left);
+    const normalizedRight = path.resolve(right);
+    return platform === "win32"
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
+function hasExecutable(pathValue, executable, platform) {
+    if (!pathValue)
+        return false;
+    const suffixes = platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+    return pathValue.split(path.delimiter).some((directory) => suffixes.some((suffix) => {
+        try {
+            fs.accessSync(path.join(directory, `${executable}${suffix}`), fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }));
+}
+function conflictMessage(operation, conflicts) {
+    return `无法${operation} Agent Skill，以下路径存在冲突：${conflicts.map((item) => item.path).join(", ")}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/utils/capability-metadata.d.ts

@@ -0,0 +1,18 @@
+export type CapabilitySource = "built-in" | "remote" | "custom" | "local";
+export type CapabilityStatus = "ready" | "login-required" | "org-required" | "unauthorized" | "quota-limited" | "error" | "deprecated" | "updating";
+export type CapabilityPolicy = "safe" | "standard" | "costly" | "batch" | "long-running" | "restricted" | "experimental";
+export interface CapabilityMetadata {
+    source: CapabilitySource;
+    status: CapabilityStatus;
+    policy: CapabilityPolicy;
+}
+export declare const SOURCE_LABELS: Record<CapabilitySource, string>;
+export declare const STATUS_LABELS: Record<CapabilityStatus, string>;
+export declare const POLICY_LABELS: Record<CapabilityPolicy, string>;
+export declare function capabilityMetadata(kind: "tool" | "app" | "skill" | "dam" | "org", id: string): CapabilityMetadata;
+export declare function policyFor(kind: "tool" | "app" | "skill" | "dam" | "org", id: string): CapabilityPolicy;
+export declare function toolPolicy(id: string): CapabilityPolicy;
+export declare function appPolicy(id: string): CapabilityPolicy;
+export declare function sourceLabel(value: unknown): string;
+export declare function statusLabel(value: unknown): string;
+export declare function policyLabel(value: unknown): string;

package/dist/src/utils/capability-metadata.js

@@ -0,0 +1,88 @@
+export const SOURCE_LABELS = {
+    "built-in": "内置",
+    remote: "云端",
+    custom: "自定义",
+    local: "本地",
+};
+export const STATUS_LABELS = {
+    ready: "启用",
+    "login-required": "需登录",
+    "org-required": "需选择团队",
+    unauthorized: "无权限",
+    "quota-limited": "额度不足",
+    error: "异常",
+    deprecated: "已弃用",
+    updating: "更新中",
+};
+export const POLICY_LABELS = {
+    safe: "安全",
+    standard: "标准",
+    costly: "高成本",
+    batch: "批量",
+    "long-running": "长任务",
+    restricted: "受限",
+    experimental: "实验",
+};
+export function capabilityMetadata(kind, id) {
+    return {
+        source: "built-in",
+        status: "ready",
+        policy: policyFor(kind, id),
+    };
+}
+export function policyFor(kind, id) {
+    if (kind === "app")
+        return appPolicy(id);
+    if (kind === "tool")
+        return toolPolicy(id);
+    return "safe";
+}
+export function toolPolicy(id) {
+    if (id === "asset.upload" || id === "text.title" || id === "text.prompt") {
+        return "safe";
+    }
+    if (id === "video.generate")
+        return "costly";
+    return "standard";
+}
+export function appPolicy(id) {
+    void id;
+    return "batch";
+}
+export function sourceLabel(value) {
+    return SOURCE_LABELS[asSource(value)];
+}
+export function statusLabel(value) {
+    return STATUS_LABELS[asStatus(value)];
+}
+export function policyLabel(value) {
+    return POLICY_LABELS[asPolicy(value)];
+}
+function asSource(value) {
+    return value === "remote" || value === "custom" || value === "local"
+        ? value
+        : "built-in";
+}
+function asStatus(value) {
+    if (value === "login-required" ||
+        value === "org-required" ||
+        value === "unauthorized" ||
+        value === "quota-limited" ||
+        value === "error" ||
+        value === "deprecated" ||
+        value === "updating") {
+        return value;
+    }
+    return "ready";
+}
+function asPolicy(value) {
+    if (value === "safe" ||
+        value === "costly" ||
+        value === "batch" ||
+        value === "long-running" ||
+        value === "restricted" ||
+        value === "experimental") {
+        return value;
+    }
+    return "standard";
+}

package/dist/src/utils/capability-presenter.d.ts

@@ -0,0 +1,4 @@
+type JsonRecord = Record<string, unknown>;
+export declare function printCapabilitySchema(payload: JsonRecord): void;
+export declare function printCapabilityExamples(payload: JsonRecord): void;
+export {};

package/dist/src/utils/capability-presenter.js

@@ -0,0 +1,190 @@
+import chalk from "chalk";
+export function printCapabilitySchema(payload) {
+    const id = stringValue(payload.id);
+    const type = stringValue(payload.type);
+    const namespace = namespaceForType(type);
+    const title = stringValue(payload.title) || id;
+    const category = stringValue(payload.category);
+    const description = stringValue(payload.description);
+    console.log(chalk.bold(`${title} (${id})`));
+    console.log(`类型: ${labelForType(type)}`);
+    if (category)
+        console.log(`分类: ${category}`);
+    if (description)
+        console.log(`说明: ${description}`);
+    const inputSchema = recordValue(payload.input_schema);
+    const outputSchema = recordValue(payload.output_schema);
+    console.log("");
+    printSchemaFields("输入参数", inputSchema, "input");
+    console.log("");
+    printSchemaFields("输出字段", outputSchema, "output");
+    const sampleInput = recordValue(payload.sample_input) ?? buildSampleInput(inputSchema);
+    if (sampleInput && Object.keys(sampleInput).length > 0) {
+        console.log("");
+        console.log(chalk.bold("最小 input.json:"));
+        console.log(indentBlock(JSON.stringify(sampleInput, null, 2), "  "));
+    }
+    const stdin = recordValue(payload.stdin);
+    const stdinCommand = stringValue(stdin?.command);
+    const canonicalCommand = stringValue(payload.canonical_command);
+    const fallbackCommand = type === "workflow"
+        ? `gd-cli workflows run ${id} --input input.json --format json`
+        : `gd-cli ${namespace} call ${id} --input input.json --format json`;
+    console.log("");
+    console.log(chalk.bold("调用方式:"));
+    console.log(`  ${canonicalCommand ?? fallbackCommand}`);
+    if (stdinCommand)
+        console.log(`  ${stdinCommand}`);
+    console.log("");
+    console.log(chalk.bold("Agent:"));
+    console.log(`  gd-cli ${namespace} schema ${id} --format json`);
+    console.log(`  gd-cli ${namespace} examples ${id} --format json`);
+}
+export function printCapabilityExamples(payload) {
+    const id = stringValue(payload.id);
+    const type = stringValue(payload.type);
+    const namespace = namespaceForType(type);
+    const title = stringValue(payload.title) || id;
+    const category = stringValue(payload.category);
+    const description = stringValue(payload.description);
+    const examples = Array.isArray(payload.examples)
+        ? payload.examples.filter(isRecord)
+        : [];
+    console.log(chalk.bold(`${title} (${id})`));
+    console.log(`类型: ${labelForType(type)}`);
+    if (category)
+        console.log(`分类: ${category}`);
+    if (description)
+        console.log(`说明: ${description}`);
+    if (examples.length === 0) {
+        console.log("\n暂无示例。");
+    }
+    examples.forEach((example, index) => {
+        const description = stringValue(example.description) || `示例 ${index + 1}`;
+        const command = stringValue(example.command);
+        const inputJson = recordValue(example.input_json);
+        console.log("");
+        console.log(chalk.bold(`示例 ${index + 1}: ${description}`));
+        if (command)
+            console.log(`  ${command}`);
+        if (inputJson && Object.keys(inputJson).length > 0) {
+            console.log("");
+            console.log("  input.json:");
+            console.log(indentBlock(JSON.stringify(inputJson, null, 2), "    "));
+        }
+    });
+    console.log("");
+    console.log(chalk.bold("Agent:"));
+    console.log(`  gd-cli ${namespace} examples ${id} --format json`);
+    console.log(`  gd-cli ${namespace} schema ${id} --format json`);
+}
+function namespaceForType(type) {
+    if (type === "workflow")
+        return "workflows";
+    if (type === "skill")
+        return "skills";
+    return "tools";
+}
+function labelForType(type) {
+    if (type === "workflow")
+        return "Workflow 场景";
+    if (type === "skill")
+        return "Skill 说明";
+    return "Tool 能力";
+}
+function printSchemaFields(title, schema, kind) {
+    console.log(chalk.bold(`${title}:`));
+    const properties = recordValue(schema?.properties);
+    const required = new Set(Array.isArray(schema?.required)
+        ? schema.required.map((item) => String(item))
+        : []);
+    if (!properties || Object.keys(properties).length === 0) {
+        console.log("  无");
+        return;
+    }
+    const names = Object.keys(properties);
+    const width = Math.max(...names.map((name) => name.length), 4);
+    for (const name of names) {
+        const prop = recordValue(properties[name]) ?? {};
+        const type = typeName(prop);
+        const requirement = kind === "input" ? (required.has(name) ? "必填" : "可选") : "";
+        const flag = stringValue(prop["x-cli-flag"]);
+        const parts = [type, requirement, flag].filter(Boolean);
+        console.log(`  ${name.padEnd(width)}  ${parts.join("  ")}`);
+        const description = stringValue(prop.description);
+        if (description)
+            console.log(`    ${description}`);
+        const details = [];
+        const format = stringValue(prop.format);
+        if (format)
+            details.push(`format: ${format}`);
+        if (Array.isArray(prop.enum) && prop.enum.length > 0) {
+            details.push(`enum: ${prop.enum.map((item) => String(item)).join(" | ")}`);
+        }
+        if (prop.default !== undefined)
+            details.push(`default: ${String(prop.default)}`);
+        if (details.length > 0)
+            console.log(`    ${details.join("; ")}`);
+    }
+}
+function buildSampleInput(schema) {
+    const properties = recordValue(schema?.properties);
+    const required = Array.isArray(schema?.required)
+        ? schema.required.map((item) => String(item))
+        : [];
+    if (!properties || required.length === 0)
+        return undefined;
+    const sample = {};
+    for (const name of required) {
+        const prop = recordValue(properties[name]) ?? {};
+        sample[name] = sampleValue(name, prop);
+    }
+    return sample;
+}
+function sampleValue(name, prop) {
+    if (prop.default !== undefined)
+        return prop.default;
+    if (Array.isArray(prop.enum) && prop.enum.length > 0)
+        return prop.enum[0];
+    const n = name.toLowerCase();
+    const type = stringValue(prop.type);
+    if (type === "boolean")
+        return true;
+    if (type === "number" || type === "integer")
+        return 1;
+    if (n.includes("image"))
+        return "./sku.png";
+    if (n.includes("assets_dir"))
+        return "./images";
+    if (n === "input")
+        return "./products.csv";
+    if (n.includes("duration"))
+        return "5";
+    if (n.includes("ratio"))
+        return "1:1";
+    if (n.includes("brief"))
+        return "夏季防晒衣，轻薄透气，适合户外通勤";
+    if (n.includes("prompt"))
+        return "生成一张干净高级的电商商品主图";
+    if (n.includes("file"))
+        return "./image.png";
+    return "value";
+}
+function indentBlock(value, prefix) {
+    return value.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function typeName(prop) {
+    const type = prop.type;
+    if (Array.isArray(type))
+        return type.map((item) => String(item)).join("|");
+    return stringValue(type) || "unknown";
+}
+function recordValue(value) {
+    return isRecord(value) ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}