@zhuan-ai/zhuanspec 1.3.0

package/dist/core/parsers/requirement-blocks.js

@@ -0,0 +1,201 @@
+export function normalizeRequirementName(name) {
+    return name.trim();
+}
+const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/;
+/**
+ * Extracts the Requirements section from a spec file and parses requirement blocks.
+ */
+export function extractRequirementsSection(content) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    const reqHeaderIndex = lines.findIndex(l => /^##\s+Requirements\s*$/i.test(l));
+    if (reqHeaderIndex === -1) {
+        // No requirements section; create an empty one at the end
+        const before = content.trimEnd();
+        const headerLine = '## Requirements';
+        return {
+            before: before ? before + '\n\n' : '',
+            headerLine,
+            preamble: '',
+            bodyBlocks: [],
+            after: '\n',
+        };
+    }
+    // Find end of this section: next line that starts with '## ' at same or higher level
+    let endIndex = lines.length;
+    for (let i = reqHeaderIndex + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i])) {
+            endIndex = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, reqHeaderIndex).join('\n');
+    const headerLine = lines[reqHeaderIndex];
+    const sectionBodyLines = lines.slice(reqHeaderIndex + 1, endIndex);
+    // Parse requirement blocks within section body
+    const blocks = [];
+    let cursor = 0;
+    let preambleLines = [];
+    // Collect preamble lines until first requirement header
+    while (cursor < sectionBodyLines.length && !/^###\s+Requirement:/.test(sectionBodyLines[cursor])) {
+        preambleLines.push(sectionBodyLines[cursor]);
+        cursor++;
+    }
+    while (cursor < sectionBodyLines.length) {
+        const headerStart = cursor;
+        const headerLineCandidate = sectionBodyLines[cursor];
+        const headerMatch = headerLineCandidate.match(REQUIREMENT_HEADER_REGEX);
+        if (!headerMatch) {
+            // Not a requirement header; skip line defensively
+            cursor++;
+            continue;
+        }
+        const name = normalizeRequirementName(headerMatch[1]);
+        cursor++;
+        // Gather lines until next requirement header or end of section
+        const bodyLines = [headerLineCandidate];
+        while (cursor < sectionBodyLines.length && !/^###\s+Requirement:/.test(sectionBodyLines[cursor]) && !/^##\s+/.test(sectionBodyLines[cursor])) {
+            bodyLines.push(sectionBodyLines[cursor]);
+            cursor++;
+        }
+        const raw = bodyLines.join('\n').trimEnd();
+        blocks.push({ headerLine: headerLineCandidate, name, raw });
+    }
+    const after = lines.slice(endIndex).join('\n');
+    const preamble = preambleLines.join('\n').trimEnd();
+    return {
+        before: before.trimEnd() ? before + '\n' : before,
+        headerLine,
+        preamble,
+        bodyBlocks: blocks,
+        after: after.startsWith('\n') ? after : '\n' + after,
+    };
+}
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n?/g, '\n');
+}
+/**
+ * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
+ */
+export function parseDeltaSpec(content) {
+    const normalized = normalizeLineEndings(content);
+    const sections = splitTopLevelSections(normalized);
+    const addedLookup = getSectionCaseInsensitive(sections, 'ADDED Requirements');
+    const modifiedLookup = getSectionCaseInsensitive(sections, 'MODIFIED Requirements');
+    const removedLookup = getSectionCaseInsensitive(sections, 'REMOVED Requirements');
+    const renamedLookup = getSectionCaseInsensitive(sections, 'RENAMED Requirements');
+    const added = parseRequirementBlocksFromSection(addedLookup.body);
+    const modified = parseRequirementBlocksFromSection(modifiedLookup.body);
+    const removedNames = parseRemovedNames(removedLookup.body);
+    const renamedPairs = parseRenamedPairs(renamedLookup.body);
+    return {
+        added,
+        modified,
+        removed: removedNames,
+        renamed: renamedPairs,
+        sectionPresence: {
+            added: addedLookup.found,
+            modified: modifiedLookup.found,
+            removed: removedLookup.found,
+            renamed: renamedLookup.found,
+        },
+    };
+}
+function splitTopLevelSections(content) {
+    const lines = content.split('\n');
+    const result = {};
+    const indices = [];
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(/^(##)\s+(.+)$/);
+        if (m) {
+            const level = m[1].length; // only care for '##'
+            indices.push({ title: m[2].trim(), index: i, level });
+        }
+    }
+    for (let i = 0; i < indices.length; i++) {
+        const current = indices[i];
+        const next = indices[i + 1];
+        const body = lines.slice(current.index + 1, next ? next.index : lines.length).join('\n');
+        result[current.title] = body;
+    }
+    return result;
+}
+function getSectionCaseInsensitive(sections, desired) {
+    const target = desired.toLowerCase();
+    for (const [title, body] of Object.entries(sections)) {
+        if (title.toLowerCase() === target)
+            return { body, found: true };
+    }
+    return { body: '', found: false };
+}
+function parseRequirementBlocksFromSection(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        // Seek next requirement header
+        while (i < lines.length && !/^###\s+Requirement:/.test(lines[i]))
+            i++;
+        if (i >= lines.length)
+            break;
+        const headerLine = lines[i];
+        const m = headerLine.match(REQUIREMENT_HEADER_REGEX);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const name = normalizeRequirementName(m[1]);
+        const buf = [headerLine];
+        i++;
+        while (i < lines.length && !/^###\s+Requirement:/.test(lines[i]) && !/^##\s+/.test(lines[i])) {
+            buf.push(lines[i]);
+            i++;
+        }
+        blocks.push({ headerLine, name, raw: buf.join('\n').trimEnd() });
+    }
+    return blocks;
+}
+function parseRemovedNames(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const names = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    for (const line of lines) {
+        const m = line.match(REQUIREMENT_HEADER_REGEX);
+        if (m) {
+            names.push(normalizeRequirementName(m[1]));
+            continue;
+        }
+        // Also support bullet list of headers
+        const bullet = line.match(/^\s*-\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (bullet) {
+            names.push(normalizeRequirementName(bullet[1]));
+        }
+    }
+    return names;
+}
+function parseRenamedPairs(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const pairs = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    let current = {};
+    for (const line of lines) {
+        const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (fromMatch) {
+            current.from = normalizeRequirementName(fromMatch[1]);
+        }
+        else if (toMatch) {
+            current.to = normalizeRequirementName(toMatch[1]);
+            if (current.from && current.to) {
+                pairs.push({ from: current.from, to: current.to });
+                current = {};
+            }
+        }
+    }
+    return pairs;
+}
+//# sourceMappingURL=requirement-blocks.js.map

package/dist/core/project-config.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Project-level configuration loaded from zhuanspec/config.yaml.
+ *
+ * Supports three key sections:
+ * - context: Project background injected into all artifact instructions
+ * - rules: Per-artifact or global rules injected into instructions
+ * - defaultSchema: Project-wide default schema name
+ */
+export interface ProjectConfig {
+    /** Project context injected into all instructions */
+    context?: string;
+    /** Global rules applied to all artifacts */
+    rules?: string;
+    /** Per-artifact rules (key = artifact ID, value = rules text) */
+    artifactRules?: Record<string, string>;
+    /** Default schema for the project */
+    defaultSchema?: string;
+}
+/**
+ * Loads project-level configuration from zhuanspec/config.yaml.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Parsed project config, or empty config if file doesn't exist
+ */
+export declare function loadProjectConfig(projectRoot: string): ProjectConfig;
+/**
+ * Gets the effective rules for a specific artifact, combining global and per-artifact rules.
+ *
+ * @param config - Project configuration
+ * @param artifactId - The artifact ID (e.g., "proposal", "specs", "tasks")
+ * @returns Combined rules string, or undefined if no rules apply
+ */
+export declare function getEffectiveRules(config: ProjectConfig, artifactId: string): string | undefined;
+//# sourceMappingURL=project-config.d.ts.map

package/dist/core/project-config.js

@@ -0,0 +1,79 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as yaml from 'yaml';
+const PROJECT_CONFIG_FILENAME = 'config.yaml';
+/**
+ * Loads project-level configuration from zhuanspec/config.yaml.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Parsed project config, or empty config if file doesn't exist
+ */
+export function loadProjectConfig(projectRoot) {
+    const configPath = path.join(projectRoot, 'zhuanspec', PROJECT_CONFIG_FILENAME);
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    let content;
+    try {
+        content = fs.readFileSync(configPath, 'utf-8');
+    }
+    catch {
+        return {};
+    }
+    if (!content.trim()) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = yaml.parse(content);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`Warning: Invalid YAML in ${configPath}: ${msg}`);
+        return {};
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        return {};
+    }
+    const raw = parsed;
+    const config = {};
+    if (typeof raw.context === 'string') {
+        config.context = raw.context;
+    }
+    if (typeof raw.rules === 'string') {
+        config.rules = raw.rules;
+    }
+    if (typeof raw.artifactRules === 'object' && raw.artifactRules !== null) {
+        const artifactRules = {};
+        for (const [key, value] of Object.entries(raw.artifactRules)) {
+            if (typeof value === 'string') {
+                artifactRules[key] = value;
+            }
+        }
+        if (Object.keys(artifactRules).length > 0) {
+            config.artifactRules = artifactRules;
+        }
+    }
+    if (typeof raw.defaultSchema === 'string') {
+        config.defaultSchema = raw.defaultSchema;
+    }
+    return config;
+}
+/**
+ * Gets the effective rules for a specific artifact, combining global and per-artifact rules.
+ *
+ * @param config - Project configuration
+ * @param artifactId - The artifact ID (e.g., "proposal", "specs", "tasks")
+ * @returns Combined rules string, or undefined if no rules apply
+ */
+export function getEffectiveRules(config, artifactId) {
+    const parts = [];
+    if (config.rules) {
+        parts.push(config.rules);
+    }
+    if (config.artifactRules?.[artifactId]) {
+        parts.push(config.artifactRules[artifactId]);
+    }
+    return parts.length > 0 ? parts.join('\n\n') : undefined;
+}
+//# sourceMappingURL=project-config.js.map

package/dist/core/schemas/base.schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const ScenarioSchema: z.ZodObject<{
+    rawText: z.ZodString;
+}, z.core.$strip>;
+export declare const RequirementSchema: z.ZodObject<{
+    text: z.ZodString;
+    scenarios: z.ZodArray<z.ZodObject<{
+        rawText: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Scenario = z.infer<typeof ScenarioSchema>;
+export type Requirement = z.infer<typeof RequirementSchema>;
+//# sourceMappingURL=base.schema.d.ts.map

package/dist/core/schemas/base.schema.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { VALIDATION_MESSAGES } from '../validation/constants.js';
+export const ScenarioSchema = z.object({
+    rawText: z.string().min(1, VALIDATION_MESSAGES.SCENARIO_EMPTY),
+});
+export const RequirementSchema = z.object({
+    text: z.string()
+        .min(1, VALIDATION_MESSAGES.REQUIREMENT_EMPTY)
+        .refine((text) => text.includes('SHALL') || text.includes('MUST'), VALIDATION_MESSAGES.REQUIREMENT_NO_SHALL),
+    scenarios: z.array(ScenarioSchema)
+        .min(1, VALIDATION_MESSAGES.REQUIREMENT_NO_SCENARIOS),
+});
+//# sourceMappingURL=base.schema.js.map

package/dist/core/schemas/change.schema.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+export declare const DeltaOperationType: z.ZodEnum<{
+    ADDED: "ADDED";
+    MODIFIED: "MODIFIED";
+    REMOVED: "REMOVED";
+    RENAMED: "RENAMED";
+}>;
+export declare const DeltaSchema: z.ZodObject<{
+    spec: z.ZodString;
+    operation: z.ZodEnum<{
+        ADDED: "ADDED";
+        MODIFIED: "MODIFIED";
+        REMOVED: "REMOVED";
+        RENAMED: "RENAMED";
+    }>;
+    description: z.ZodString;
+    requirement: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            rawText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            rawText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    rename: z.ZodOptional<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ChangeSchema: z.ZodObject<{
+    name: z.ZodString;
+    why: z.ZodString;
+    whatChanges: z.ZodString;
+    deltas: z.ZodArray<z.ZodObject<{
+        spec: z.ZodString;
+        operation: z.ZodEnum<{
+            ADDED: "ADDED";
+            MODIFIED: "MODIFIED";
+            REMOVED: "REMOVED";
+            RENAMED: "RENAMED";
+        }>;
+        description: z.ZodString;
+        requirement: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+            scenarios: z.ZodArray<z.ZodObject<{
+                rawText: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            scenarios: z.ZodArray<z.ZodObject<{
+                rawText: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        rename: z.ZodOptional<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodDefault<z.ZodString>;
+        format: z.ZodLiteral<"zhuanspec-change">;
+        sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DeltaOperation = z.infer<typeof DeltaOperationType>;
+export type Delta = z.infer<typeof DeltaSchema>;
+export type Change = z.infer<typeof ChangeSchema>;
+//# sourceMappingURL=change.schema.d.ts.map

package/dist/core/schemas/change.schema.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { RequirementSchema } from './base.schema.js';
+import { MIN_WHY_SECTION_LENGTH, MAX_WHY_SECTION_LENGTH, MAX_DELTAS_PER_CHANGE, VALIDATION_MESSAGES } from '../validation/constants.js';
+export const DeltaOperationType = z.enum(['ADDED', 'MODIFIED', 'REMOVED', 'RENAMED']);
+export const DeltaSchema = z.object({
+    spec: z.string().min(1, VALIDATION_MESSAGES.DELTA_SPEC_EMPTY),
+    operation: DeltaOperationType,
+    description: z.string().min(1, VALIDATION_MESSAGES.DELTA_DESCRIPTION_EMPTY),
+    requirement: RequirementSchema.optional(),
+    requirements: z.array(RequirementSchema).optional(),
+    rename: z.object({
+        from: z.string(),
+        to: z.string(),
+    }).optional(),
+});
+export const ChangeSchema = z.object({
+    name: z.string().min(1, VALIDATION_MESSAGES.CHANGE_NAME_EMPTY),
+    why: z.string()
+        .min(MIN_WHY_SECTION_LENGTH, VALIDATION_MESSAGES.CHANGE_WHY_TOO_SHORT)
+        .max(MAX_WHY_SECTION_LENGTH, VALIDATION_MESSAGES.CHANGE_WHY_TOO_LONG),
+    whatChanges: z.string().min(1, VALIDATION_MESSAGES.CHANGE_WHAT_EMPTY),
+    deltas: z.array(DeltaSchema)
+        .min(1, VALIDATION_MESSAGES.CHANGE_NO_DELTAS)
+        .max(MAX_DELTAS_PER_CHANGE, VALIDATION_MESSAGES.CHANGE_TOO_MANY_DELTAS),
+    metadata: z.object({
+        version: z.string().default('1.0.0'),
+        format: z.literal('zhuanspec-change'),
+        sourcePath: z.string().optional(),
+    }).optional(),
+});
+//# sourceMappingURL=change.schema.js.map

package/dist/core/schemas/index.d.ts

@@ -0,0 +1,4 @@
+export { ScenarioSchema, RequirementSchema, type Scenario, type Requirement, } from './base.schema.js';
+export { SpecSchema, type Spec, } from './spec.schema.js';
+export { DeltaOperationType, DeltaSchema, ChangeSchema, type DeltaOperation, type Delta, type Change, } from './change.schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/schemas/index.js

@@ -0,0 +1,4 @@
+export { ScenarioSchema, RequirementSchema, } from './base.schema.js';
+export { SpecSchema, } from './spec.schema.js';
+export { DeltaOperationType, DeltaSchema, ChangeSchema, } from './change.schema.js';
+//# sourceMappingURL=index.js.map

package/dist/core/schemas/spec.schema.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const SpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    overview: z.ZodString;
+    requirements: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            rawText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodDefault<z.ZodString>;
+        format: z.ZodLiteral<"zhuanspec">;
+        sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Spec = z.infer<typeof SpecSchema>;
+//# sourceMappingURL=spec.schema.d.ts.map

package/dist/core/schemas/spec.schema.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { RequirementSchema } from './base.schema.js';
+import { VALIDATION_MESSAGES } from '../validation/constants.js';
+export const SpecSchema = z.object({
+    name: z.string().min(1, VALIDATION_MESSAGES.SPEC_NAME_EMPTY),
+    overview: z.string().min(1, VALIDATION_MESSAGES.SPEC_PURPOSE_EMPTY),
+    requirements: z.array(RequirementSchema)
+        .min(1, VALIDATION_MESSAGES.SPEC_NO_REQUIREMENTS),
+    metadata: z.object({
+        version: z.string().default('1.0.0'),
+        format: z.literal('zhuanspec'),
+        sourcePath: z.string().optional(),
+    }).optional(),
+});
+//# sourceMappingURL=spec.schema.js.map

package/dist/core/skill-discovery.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Represents a discovered skill from the filesystem.
+ */
+export interface DiscoveredSkill {
+    /** Skill name from YAML frontmatter */
+    name: string;
+    /** Skill description from YAML frontmatter */
+    description: string;
+    /** Absolute path to the SKILL.md file */
+    filePath: string;
+}
+/**
+ * Discover available skills by scanning priority paths.
+ * Uses short-circuit strategy: once a non-empty directory is found, stops scanning.
+ *
+ * @param _projectRoot - Project root path (reserved for future project-level skill scanning)
+ * @returns Array of discovered skills
+ */
+export declare function discoverSkills(_projectRoot?: string): DiscoveredSkill[];
+/**
+ * Format discovered skills for display.
+ */
+export declare function formatSkillsList(skills: DiscoveredSkill[], json: boolean): string;
+//# sourceMappingURL=skill-discovery.d.ts.map

package/dist/core/skill-discovery.js

@@ -0,0 +1,153 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * Scan priority paths (highest to lowest).
+ * Once a non-empty directory is found, scanning stops (short-circuit strategy).
+ */
+const SCAN_PRIORITY = [
+    '~/.ai-config-hub/skills',
+    // Future fallback paths can be added here
+];
+/**
+ * Resolve a path that may contain ~ to an absolute path.
+ */
+function resolvePath(p) {
+    if (p.startsWith('~/') || p === '~') {
+        return path.join(os.homedir(), p.slice(1));
+    }
+    return path.resolve(p);
+}
+/**
+ * Parse YAML frontmatter from a SKILL.md file content.
+ * Frontmatter is delimited by --- at the start of the file.
+ */
+function parseFrontmatter(content) {
+    const trimmed = content.trimStart();
+    if (!trimmed.startsWith('---')) {
+        return {};
+    }
+    const endIndex = trimmed.indexOf('---', 3);
+    if (endIndex === -1) {
+        return {};
+    }
+    const frontmatterBlock = trimmed.slice(3, endIndex).trim();
+    const result = {};
+    for (const line of frontmatterBlock.split('\n')) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const key = line.slice(0, colonIndex).trim();
+        const value = line.slice(colonIndex + 1).trim();
+        // Remove quotes if present
+        const unquoted = value.replace(/^["']|["']$/g, '');
+        if (key === 'name') {
+            result.name = unquoted;
+        }
+        else if (key === 'description') {
+            result.description = unquoted;
+        }
+    }
+    return result;
+}
+/**
+ * Recursively find all SKILL.md files under a directory.
+ */
+function findSkillFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...findSkillFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name === 'SKILL.md') {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+/**
+ * Discover available skills by scanning priority paths.
+ * Uses short-circuit strategy: once a non-empty directory is found, stops scanning.
+ *
+ * @param _projectRoot - Project root path (reserved for future project-level skill scanning)
+ * @returns Array of discovered skills
+ */
+export function discoverSkills(_projectRoot) {
+    for (const scanPath of SCAN_PRIORITY) {
+        const resolved = resolvePath(scanPath);
+        // Check if directory exists
+        try {
+            const stat = fs.statSync(resolved);
+            if (!stat.isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        // Scan for SKILL.md files
+        const skillFiles = findSkillFiles(resolved);
+        if (skillFiles.length === 0)
+            continue;
+        // Parse skills from found files
+        const skills = [];
+        const seenNames = new Set();
+        for (const filePath of skillFiles) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const fm = parseFrontmatter(content);
+                if (!fm.name)
+                    continue;
+                // Filter out zhuanspec-* workflow skills
+                if (fm.name.startsWith('zhuanspec-'))
+                    continue;
+                // Deduplicate by name
+                if (seenNames.has(fm.name))
+                    continue;
+                seenNames.add(fm.name);
+                skills.push({
+                    name: fm.name,
+                    description: fm.description || '',
+                    filePath,
+                });
+            }
+            catch {
+                // Skip unreadable files
+                continue;
+            }
+        }
+        // Short-circuit: found a valid directory with skills, stop scanning
+        if (skills.length > 0) {
+            return skills;
+        }
+    }
+    // No skills found in any priority path
+    return [];
+}
+/**
+ * Format discovered skills for display.
+ */
+export function formatSkillsList(skills, json) {
+    if (json) {
+        return JSON.stringify(skills.map(s => ({ name: s.name, description: s.description, filePath: s.filePath })), null, 2);
+    }
+    if (skills.length === 0) {
+        return 'No skills discovered.';
+    }
+    const lines = [`Found ${skills.length} skill(s):\n`];
+    for (const skill of skills) {
+        lines.push(`  ${skill.name}`);
+        if (skill.description) {
+            lines.push(`    ${skill.description}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=skill-discovery.js.map