@biaoo/tiangong-wiki 0.2.0 → 0.2.2

package/dist/core/workspace-skills.js

@@ -1,9 +1,14 @@
+import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
-import { accessSync, constants, lstatSync, realpathSync, rmSync, symlinkSync, unlinkSync } from "node:fs";
+import { accessSync, constants, lstatSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, symlinkSync, unlinkSync, } from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { AppError } from "../utils/errors.js";
-import { ensureDirSync, pathExistsSync } from "../utils/fs.js";
+import { copyDirectoryContentsSync, ensureDirSync, pathExistsSync, readTextFileSync, writeTextFileSync } from "../utils/fs.js";
+import { resolveRuntimePaths } from "./paths.js";
+import { toOffsetIso } from "../utils/time.js";
 export const PARSER_SKILL_SOURCE = "https://github.com/anthropics/skills";
+export const MANAGED_SKILL_STATE_FILE = ".tiangong-wiki-skill.json";
 export const OPTIONAL_PARSER_SKILLS = [
     { name: "pdf", summary: "Process PDF files" },
     { name: "docx", summary: "Process DOCX files" },
@@ -11,6 +16,11 @@ export const OPTIONAL_PARSER_SKILLS = [
     { name: "xlsx", summary: "Process XLSX/CSV files" },
 ];
 const OPTIONAL_PARSER_SKILL_NAMES = new Set(OPTIONAL_PARSER_SKILLS.map((skill) => skill.name));
+const MANAGED_SKILL_SOURCE_KINDS = new Set([
+    "workspace-package",
+    "curated-parser",
+    "external-source",
+]);
 function canRead(filePath) {
     accessSync(filePath, constants.R_OK);
     return true;
@@ -105,49 +115,142 @@ export function inspectSkillInstall(skillPath, name = path.basename(skillPath))
         };
     }
 }
-export function ensureWikiSkillInstall(wikiPath, packageRoot) {
-    const paths = resolveWorkspaceSkillPaths(wikiPath);
-    const packageRealPath = realpathSync(packageRoot);
-    const existing = inspectSkillInstall(paths.wikiSkillPath, "tiangong-wiki-skill");
-    ensureDirSync(paths.skillsRoot);
-    if (existing.exists) {
-        const stats = lstatSync(paths.wikiSkillPath);
-        if (stats.isSymbolicLink()) {
-            const currentRealPath = realpathSync(paths.wikiSkillPath);
-            if (currentRealPath === packageRealPath) {
-                return {
-                    sourcePath: packageRoot,
-                    skillPath: paths.wikiSkillPath,
-                    status: "linked",
-                };
-            }
-            unlinkSync(paths.wikiSkillPath);
-            symlinkSync(packageRoot, paths.wikiSkillPath, "dir");
-            return {
-                sourcePath: packageRoot,
-                skillPath: paths.wikiSkillPath,
-                status: "updated",
-            };
+function getManagedSkillStatePath(skillPath) {
+    return path.join(skillPath, MANAGED_SKILL_STATE_FILE);
+}
+function readManagedSkillMetadata(skillPath) {
+    const metadataPath = getManagedSkillStatePath(skillPath);
+    if (!pathExistsSync(metadataPath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readTextFileSync(metadataPath));
+        if (parsed.version !== 1 ||
+            typeof parsed.skillName !== "string" ||
+            typeof parsed.sourceKind !== "string" ||
+            !MANAGED_SKILL_SOURCE_KINDS.has(parsed.sourceKind) ||
+            typeof parsed.source !== "string" ||
+            typeof parsed.installedAt !== "string" ||
+            typeof parsed.baselineHash !== "string") {
+            return null;
         }
-        if (existing.readable) {
-            rmSync(paths.wikiSkillPath, { recursive: true, force: true });
-            symlinkSync(packageRoot, paths.wikiSkillPath, "dir");
-            return {
-                sourcePath: packageRoot,
-                skillPath: paths.wikiSkillPath,
-                status: "updated",
-            };
+        return {
+            version: 1,
+            skillName: parsed.skillName,
+            sourceKind: parsed.sourceKind,
+            source: parsed.source,
+            installedAt: parsed.installedAt,
+            baselineHash: parsed.baselineHash,
+            ...(typeof parsed.command === "string" ? { command: parsed.command } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writeManagedSkillMetadata(skillPath, metadata) {
+    writeTextFileSync(getManagedSkillStatePath(skillPath), `${JSON.stringify(metadata, null, 2)}\n`);
+}
+function hashSkillDirectory(skillPath) {
+    const hash = createHash("sha256");
+    const visit = (dirPath, relativePrefix) => {
+        const entries = readdirSync(dirPath, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            if (entry.name === MANAGED_SKILL_STATE_FILE) {
+                continue;
+            }
+            const absolutePath = path.join(dirPath, entry.name);
+            const relativePath = path.posix.join(relativePrefix, entry.name);
+            const stats = lstatSync(absolutePath);
+            if (stats.isSymbolicLink()) {
+                hash.update(`symlink:${relativePath}:${realpathSync(absolutePath)}\n`);
+                continue;
+            }
+            if (stats.isDirectory()) {
+                hash.update(`dir:${relativePath}\n`);
+                visit(absolutePath, relativePath);
+                continue;
+            }
+            hash.update(`file:${relativePath}\n`);
+            hash.update(readFileSync(absolutePath));
         }
-        throw new AppError(`workspace skill path is occupied and cannot be reused: ${paths.wikiSkillPath}`, "config", {
-            skillName: "tiangong-wiki-skill",
-            skillPath: paths.wikiSkillPath,
-        });
+    };
+    visit(skillPath, "");
+    return hash.digest("hex");
+}
+function getWorkspaceRootForSkillPath(skillPath) {
+    return path.dirname(path.dirname(path.dirname(skillPath)));
+}
+function replaceSkillDirectory(targetPath, sourcePath) {
+    rmSync(targetPath, { recursive: true, force: true });
+    ensureDirSync(targetPath);
+    copyDirectoryContentsSync(sourcePath, targetPath);
+}
+function createManagedSkillMetadata(descriptor, baselineHash, command) {
+    return {
+        version: 1,
+        skillName: descriptor.name,
+        sourceKind: descriptor.sourceKind,
+        source: descriptor.source,
+        installedAt: toOffsetIso(),
+        baselineHash,
+        ...(command ? { command } : {}),
+    };
+}
+function ensureParserSkillName(rawName) {
+    const normalized = rawName.trim().toLowerCase();
+    if (!OPTIONAL_PARSER_SKILL_NAMES.has(normalized)) {
+        throw new AppError(`Unsupported parser skill: ${rawName}`, "config");
     }
-    symlinkSync(packageRoot, paths.wikiSkillPath, "dir");
+    return normalized;
+}
+function normalizeCustomSkillName(rawName) {
+    const name = rawName.trim();
+    if (!name) {
+        throw new AppError("Skill name must not be empty.", "config");
+    }
+    if (name === "." || name === ".." || name.includes("/") || name.includes("\\")) {
+        throw new AppError(`Skill name must be a single directory-friendly token, got ${rawName}`, "config");
+    }
+    if (name === "tiangong-wiki-skill") {
+        throw new AppError("Skill name tiangong-wiki-skill is reserved for the workspace package skill.", "config");
+    }
+    return name;
+}
+function normalizeManagedSource(rawSource) {
+    const source = rawSource.trim();
+    if (!source) {
+        throw new AppError("Skill source must not be empty.", "config");
+    }
+    return source;
+}
+function createParserDescriptor(workspaceRoot, name, configured) {
     return {
-        sourcePath: packageRoot,
+        name,
+        sourceKind: "curated-parser",
+        configured,
+        source: PARSER_SKILL_SOURCE,
+        skillPath: resolveWorkspaceSkillPath(workspaceRoot, name),
+    };
+}
+function createExternalDescriptor(workspaceRoot, name, source) {
+    const normalizedName = normalizeCustomSkillName(name);
+    return {
+        name: normalizedName,
+        sourceKind: "external-source",
+        configured: true,
+        source: normalizeManagedSource(source),
+        skillPath: resolveWorkspaceSkillPath(workspaceRoot, normalizedName),
+    };
+}
+function createWikiDescriptor(wikiPath, packageRoot) {
+    const paths = resolveWorkspaceSkillPaths(wikiPath);
+    return {
+        name: "tiangong-wiki-skill",
+        sourceKind: "workspace-package",
+        configured: true,
+        source: packageRoot,
         skillPath: paths.wikiSkillPath,
-        status: "linked",
     };
 }
 function renderCommand(command, args) {
@@ -155,44 +258,50 @@ function renderCommand(command, args) {
         .map((part) => (/[A-Za-z0-9_./:@+-]+/.test(part) ? part : JSON.stringify(part)))
         .join(" ");
 }
-export function buildParserSkillInstallInvocation(skillName) {
+export function buildExternalSkillInstallInvocation(source, skillName) {
     const command = getNpxCommand();
-    const args = ["-y", "skills", "add", PARSER_SKILL_SOURCE, "--skill", skillName, "-a", "codex", "-y"];
+    const args = ["-y", "skills", "add", source, "--skill", skillName, "-a", "codex", "-y"];
     return {
         command,
         args,
         rendered: renderCommand(command, args),
     };
 }
-export function installParserSkill(skillName, workspaceRoot, options = {}) {
-    const skillPath = resolveWorkspaceSkillPath(workspaceRoot, skillName);
-    const current = inspectSkillInstall(skillPath, skillName);
-    const invocation = buildParserSkillInstallInvocation(skillName);
-    if (current.readable) {
+function installManagedExternalSkill(descriptor, options = {}) {
+    if (descriptor.sourceKind === "workspace-package") {
+        throw new AppError("Workspace package skills must be installed via ensureWikiSkillInstall.", "config");
+    }
+    const current = inspectSkillInstall(descriptor.skillPath, descriptor.name);
+    const invocation = buildExternalSkillInstallInvocation(descriptor.source, descriptor.name);
+    if (current.readable && options.skipIfExists !== false) {
         return {
-            name: skillName,
-            skillPath,
+            name: descriptor.name,
+            source: descriptor.source,
+            skillPath: descriptor.skillPath,
             skillMdPath: current.skillMdPath,
             status: "existing",
             command: invocation.rendered,
         };
     }
-    options.output?.write(`Installing parser skill ${skillName}...\n`);
+    const workspaceRoot = getWorkspaceRootForSkillPath(descriptor.skillPath);
+    options.output?.write(`Installing skill ${descriptor.name} from ${descriptor.source}...\n`);
     const result = spawnSync(invocation.command, invocation.args, {
         cwd: workspaceRoot,
         env: options.env ?? process.env,
         encoding: "utf8",
     });
     if (result.error) {
-        throw new AppError(`failed to install parser skill ${skillName}: ${result.error.message}`, "runtime", {
-            skillName,
+        throw new AppError(`failed to install skill ${descriptor.name}: ${result.error.message}`, "runtime", {
+            skillName: descriptor.name,
+            source: descriptor.source,
             command: invocation.rendered,
             cwd: workspaceRoot,
         });
     }
     if (result.status !== 0) {
-        throw new AppError(`failed to install parser skill ${skillName}`, "runtime", {
-            skillName,
+        throw new AppError(`failed to install skill ${descriptor.name}`, "runtime", {
+            skillName: descriptor.name,
+            source: descriptor.source,
             command: invocation.rendered,
             cwd: workspaceRoot,
             exitCode: result.status,
@@ -200,21 +309,348 @@ export function installParserSkill(skillName, workspaceRoot, options = {}) {
             stderr: result.stderr.trim(),
         });
     }
-    const installed = inspectSkillInstall(skillPath, skillName);
+    const installed = inspectSkillInstall(descriptor.skillPath, descriptor.name);
     if (!installed.readable) {
-        throw new AppError(`parser skill ${skillName} was installed but SKILL.md is missing or unreadable`, "runtime", {
-            skillName,
+        throw new AppError(`skill ${descriptor.name} was installed but SKILL.md is missing or unreadable`, "runtime", {
+            skillName: descriptor.name,
+            source: descriptor.source,
             command: invocation.rendered,
             cwd: workspaceRoot,
-            skillPath,
+            skillPath: descriptor.skillPath,
             skillMdPath: installed.skillMdPath,
         });
     }
+    if (options.trackMetadata !== false) {
+        writeManagedSkillMetadata(descriptor.skillPath, createManagedSkillMetadata(descriptor, hashSkillDirectory(descriptor.skillPath), invocation.rendered));
+    }
     return {
-        name: skillName,
-        skillPath,
+        name: descriptor.name,
+        source: descriptor.source,
+        skillPath: descriptor.skillPath,
         skillMdPath: installed.skillMdPath,
         status: "installed",
         command: invocation.rendered,
     };
 }
+function installManagedExternalSkillIntoTempWorkspace(descriptor, options = {}) {
+    const tempRoot = mkdtempSync(path.join(os.tmpdir(), "tiangong-wiki-skill-update-"));
+    try {
+        const result = installManagedExternalSkill({
+            ...descriptor,
+            skillPath: resolveWorkspaceSkillPath(tempRoot, descriptor.name),
+        }, {
+            env: options.env,
+            trackMetadata: false,
+        });
+        return {
+            hash: hashSkillDirectory(resolveWorkspaceSkillPath(tempRoot, descriptor.name)),
+            tempRoot,
+            invocation: result.command,
+        };
+    }
+    catch (error) {
+        rmSync(tempRoot, { recursive: true, force: true });
+        throw error;
+    }
+}
+function hasCompatibleManagedMetadata(metadata, descriptor) {
+    return metadata !== null &&
+        metadata.skillName === descriptor.name &&
+        metadata.sourceKind === descriptor.sourceKind &&
+        metadata.source === descriptor.source;
+}
+function readManagedSkillDescriptorsFromMetadata(workspaceRoot, options = {}) {
+    const skillsRoot = path.join(workspaceRoot, ".agents", "skills");
+    if (!pathExistsSync(skillsRoot)) {
+        return [];
+    }
+    const includeKinds = options.includeSourceKinds ? new Set(options.includeSourceKinds) : null;
+    const descriptors = [];
+    const entries = readdirSync(skillsRoot, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) {
+            continue;
+        }
+        const skillPath = path.join(skillsRoot, entry.name);
+        const metadata = readManagedSkillMetadata(skillPath);
+        if (!metadata || metadata.skillName !== entry.name) {
+            continue;
+        }
+        if (includeKinds && !includeKinds.has(metadata.sourceKind)) {
+            continue;
+        }
+        descriptors.push({
+            name: metadata.skillName,
+            sourceKind: metadata.sourceKind,
+            configured: true,
+            source: metadata.source,
+            skillPath,
+        });
+    }
+    return descriptors;
+}
+function createManagedSkillCatalog(env = process.env) {
+    const paths = resolveRuntimePaths(env);
+    const workspace = resolveWorkspaceSkillPaths(paths.wikiPath);
+    const configuredParserSkills = parseParserSkills(env.WIKI_PARSER_SKILLS, { strict: false });
+    return {
+        wikiDescriptor: createWikiDescriptor(paths.wikiPath, paths.packageRoot),
+        configuredParserDescriptors: configuredParserSkills.map((name) => createParserDescriptor(workspace.workspaceRoot, name, true)),
+        discoveredDescriptors: readManagedSkillDescriptorsFromMetadata(workspace.workspaceRoot),
+    };
+}
+function resolveManagedSkillDescriptorByName(env, name) {
+    const catalog = createManagedSkillCatalog(env);
+    if (name === "tiangong-wiki-skill") {
+        return catalog.wikiDescriptor;
+    }
+    const discovered = catalog.discoveredDescriptors.find((descriptor) => descriptor.name === name);
+    if (discovered) {
+        return discovered;
+    }
+    if (OPTIONAL_PARSER_SKILL_NAMES.has(name)) {
+        return createParserDescriptor(getWorkspaceRootForSkillPath(catalog.wikiDescriptor.skillPath), name, catalog.configuredParserDescriptors.some((descriptor) => descriptor.name === name));
+    }
+    throw new AppError(`Unknown managed skill: ${name}`, "config");
+}
+function resolveManagedSkillDescriptors(env = process.env, names) {
+    if (names && names.length > 0) {
+        return names.map((name) => resolveManagedSkillDescriptorByName(env, name));
+    }
+    const catalog = createManagedSkillCatalog(env);
+    const descriptors = new Map();
+    for (const descriptor of catalog.discoveredDescriptors) {
+        if (descriptor.sourceKind === "external-source") {
+            descriptors.set(descriptor.name, descriptor);
+        }
+    }
+    descriptors.set(catalog.wikiDescriptor.name, catalog.wikiDescriptor);
+    for (const descriptor of catalog.configuredParserDescriptors) {
+        if (!descriptors.has(descriptor.name)) {
+            descriptors.set(descriptor.name, descriptor);
+        }
+    }
+    return [...descriptors.values()];
+}
+function getWikiSkillStatus(descriptor) {
+    const current = inspectSkillInstall(descriptor.skillPath, descriptor.name);
+    if (!current.readable) {
+        return {
+            ...descriptor,
+            state: "missing",
+            tracked: false,
+            message: "Skill is missing or unreadable.",
+        };
+    }
+    const stats = lstatSync(descriptor.skillPath);
+    if (!stats.isSymbolicLink()) {
+        return {
+            ...descriptor,
+            state: "conflict",
+            tracked: false,
+            message: "Workspace skill path is a local directory, not the managed symlink target.",
+        };
+    }
+    if (realpathSync(descriptor.skillPath) !== realpathSync(descriptor.source)) {
+        return {
+            ...descriptor,
+            state: "update_available",
+            tracked: true,
+            message: "Symlink points to an older or different package root.",
+        };
+    }
+    return {
+        ...descriptor,
+        state: "up_to_date",
+        tracked: true,
+        message: "Symlink points to the current package root.",
+    };
+}
+function getExternalManagedSkillStatus(descriptor, env = process.env) {
+    const current = inspectSkillInstall(descriptor.skillPath, descriptor.name);
+    if (!current.readable) {
+        return {
+            ...descriptor,
+            state: "missing",
+            tracked: false,
+            message: "Skill is missing or unreadable.",
+        };
+    }
+    const currentHash = hashSkillDirectory(descriptor.skillPath);
+    const metadata = readManagedSkillMetadata(descriptor.skillPath);
+    const latest = installManagedExternalSkillIntoTempWorkspace(descriptor, { env });
+    try {
+        if (!hasCompatibleManagedMetadata(metadata, descriptor)) {
+            if (currentHash === latest.hash) {
+                return {
+                    ...descriptor,
+                    state: "up_to_date",
+                    tracked: false,
+                    message: "Installed skill matches the latest source snapshot, but no compatible managed baseline metadata exists yet.",
+                };
+            }
+            return {
+                ...descriptor,
+                state: "conflict",
+                tracked: false,
+                message: "Installed skill differs from the latest source snapshot, but no compatible managed baseline metadata exists to separate local edits from source changes.",
+            };
+        }
+        if (currentHash === latest.hash) {
+            return {
+                ...descriptor,
+                state: "up_to_date",
+                tracked: true,
+                message: "Installed skill matches the latest source snapshot.",
+            };
+        }
+        if (currentHash === metadata.baselineHash) {
+            return {
+                ...descriptor,
+                state: "update_available",
+                tracked: true,
+                message: "A newer source snapshot is available and local files are unchanged.",
+            };
+        }
+        return {
+            ...descriptor,
+            state: "conflict",
+            tracked: true,
+            message: metadata.baselineHash === latest.hash
+                ? "Local files differ from the managed baseline."
+                : "Local files and source snapshot both differ from the managed baseline.",
+        };
+    }
+    finally {
+        rmSync(latest.tempRoot, { recursive: true, force: true });
+    }
+}
+export function getManagedSkillStatus(env = process.env, names) {
+    return resolveManagedSkillDescriptors(env, names)
+        .map((descriptor) => descriptor.sourceKind === "workspace-package" ? getWikiSkillStatus(descriptor) : getExternalManagedSkillStatus(descriptor, env))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+function updateWikiManagedSkill(descriptor, env = process.env, options = {}) {
+    const status = getWikiSkillStatus(descriptor);
+    if (status.state === "conflict" && !options.force) {
+        return {
+            ...status,
+            action: "skipped",
+            message: `${status.message} Re-run with --force to replace it with the managed symlink.`,
+        };
+    }
+    const paths = resolveRuntimePaths(env);
+    const installed = ensureWikiSkillInstall(paths.wikiPath, paths.packageRoot);
+    const nextStatus = getWikiSkillStatus(descriptor);
+    return {
+        ...nextStatus,
+        action: status.state === "missing" ? "installed" : installed.status === "linked" ? "unchanged" : "updated",
+    };
+}
+function updateExternalManagedSkill(descriptor, env = process.env, options = {}) {
+    const currentStatus = getExternalManagedSkillStatus(descriptor, env);
+    if (currentStatus.state === "missing") {
+        installManagedExternalSkill(descriptor, { env });
+        return {
+            ...getExternalManagedSkillStatus(descriptor, env),
+            action: "installed",
+        };
+    }
+    if (currentStatus.state === "conflict" && !options.force) {
+        return {
+            ...currentStatus,
+            action: "skipped",
+            message: `${currentStatus.message} Refusing to overwrite local changes without --force.`,
+        };
+    }
+    const latest = installManagedExternalSkillIntoTempWorkspace(descriptor, { env });
+    try {
+        const latestSkillPath = resolveWorkspaceSkillPath(latest.tempRoot, descriptor.name);
+        const currentHash = hashSkillDirectory(descriptor.skillPath);
+        const action = currentHash === latest.hash ? "unchanged" : "updated";
+        if (action === "updated") {
+            replaceSkillDirectory(descriptor.skillPath, latestSkillPath);
+        }
+        writeManagedSkillMetadata(descriptor.skillPath, createManagedSkillMetadata(descriptor, latest.hash, latest.invocation));
+        return {
+            ...getExternalManagedSkillStatus(descriptor, env),
+            action,
+        };
+    }
+    finally {
+        rmSync(latest.tempRoot, { recursive: true, force: true });
+    }
+}
+export function updateManagedSkills(env = process.env, names, options = {}) {
+    return resolveManagedSkillDescriptors(env, names)
+        .map((descriptor) => descriptor.sourceKind === "workspace-package"
+        ? updateWikiManagedSkill(descriptor, env, options)
+        : updateExternalManagedSkill(descriptor, env, options))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+export function addManagedSkill(env = process.env, source, skillName, options = {}) {
+    const paths = resolveRuntimePaths(env);
+    const workspace = resolveWorkspaceSkillPaths(paths.wikiPath);
+    return updateExternalManagedSkill(createExternalDescriptor(workspace.workspaceRoot, skillName, source), env, options);
+}
+export function ensureWikiSkillInstall(wikiPath, packageRoot) {
+    const paths = resolveWorkspaceSkillPaths(wikiPath);
+    const packageRealPath = realpathSync(packageRoot);
+    const existing = inspectSkillInstall(paths.wikiSkillPath, "tiangong-wiki-skill");
+    ensureDirSync(paths.skillsRoot);
+    if (existing.exists) {
+        const stats = lstatSync(paths.wikiSkillPath);
+        if (stats.isSymbolicLink()) {
+            const currentRealPath = realpathSync(paths.wikiSkillPath);
+            if (currentRealPath === packageRealPath) {
+                return {
+                    sourcePath: packageRoot,
+                    skillPath: paths.wikiSkillPath,
+                    status: "linked",
+                };
+            }
+            unlinkSync(paths.wikiSkillPath);
+            symlinkSync(packageRoot, paths.wikiSkillPath, "dir");
+            return {
+                sourcePath: packageRoot,
+                skillPath: paths.wikiSkillPath,
+                status: "updated",
+            };
+        }
+        if (existing.readable) {
+            rmSync(paths.wikiSkillPath, { recursive: true, force: true });
+            symlinkSync(packageRoot, paths.wikiSkillPath, "dir");
+            return {
+                sourcePath: packageRoot,
+                skillPath: paths.wikiSkillPath,
+                status: "updated",
+            };
+        }
+        throw new AppError(`workspace skill path is occupied and cannot be reused: ${paths.wikiSkillPath}`, "config", {
+            skillName: "tiangong-wiki-skill",
+            skillPath: paths.wikiSkillPath,
+        });
+    }
+    symlinkSync(packageRoot, paths.wikiSkillPath, "dir");
+    return {
+        sourcePath: packageRoot,
+        skillPath: paths.wikiSkillPath,
+        status: "linked",
+    };
+}
+export function buildParserSkillInstallInvocation(skillName) {
+    return buildExternalSkillInstallInvocation(PARSER_SKILL_SOURCE, skillName);
+}
+export function installParserSkill(skillName, workspaceRoot, options = {}) {
+    const installed = installManagedExternalSkill(createParserDescriptor(workspaceRoot, skillName, true), {
+        env: options.env,
+        output: options.output,
+    });
+    return {
+        name: skillName,
+        skillPath: installed.skillPath,
+        skillMdPath: installed.skillMdPath,
+        status: installed.status,
+        command: installed.command,
+    };
+}

package/dist/daemon/server.js

@@ -7,6 +7,7 @@ import { exportGraphContent, exportIndexContent } from "../operations/export.js"
 import { getDashboardGraphOverview, getDashboardLintSummary, getDashboardPageDetail, getDashboardPageSource, getDashboardQueueItemDetail, getDashboardQueueSummary, getDashboardStatus, getDashboardVaultFileDetail, getDashboardVaultSummary, listDashboardLintIssues, listDashboardQueueItems, listDashboardVaultFiles, openDashboardPageSource, openDashboardVaultFile, retryDashboardQueueItem, searchDashboardGraph, } from "../operations/dashboard.js";
 import { diffVaultFiles, findPages, ftsSearchPages, getPageInfo, getVaultQueue, getWikiStat, listPages, listVaultFiles, renderLintResult, runLint, searchPages, traverseGraph, } from "../operations/query.js";
 import { createTemplate, listTemplates, listTypes, recommendTypes, showTemplate, showType, } from "../operations/type-template.js";
+import { runTemplateLint } from "../operations/template-lint.js";
 import { createPage, runSync, runSyncCommand } from "../operations/write.js";
 import { AppError, asAppError } from "../utils/errors.js";
 import { pathExistsSync } from "../utils/fs.js";
@@ -726,6 +727,13 @@ export async function runDaemonServer(options) {
                 writeJsonResponse(response, 200, showTemplate(env, pageType));
                 return;
             }
+            if (method === "GET" && pathname === "/template/lint") {
+                writeJsonResponse(response, 200, runTemplateLint(env, {
+                    pageType: url.searchParams.get("pageType") ?? undefined,
+                    level: url.searchParams.get("level") ?? undefined,
+                }));
+                return;
+            }
             if (method === "POST" && pathname === "/template/create") {
                 const body = await readJsonBody(request);
                 const result = await runWriteTask("template-create", () => Promise.resolve(createTemplate(env, {