@sstar/skill-install 1.0.0 → 1.0.1

package/dist/cli.js

@@ -6,9 +6,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const readline_1 = __importDefault(require("readline"));
+const os_1 = __importDefault(require("os"));
 const install_service_1 = require("./installer/install-service");
 const skills_manager_1 = require("./skills/skills-manager");
 const logger_1 = require("./core/logger");
+const wiki_1 = require("./wiki");
+// Color codes for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m'
+};
 const program = new commander_1.Command();
 const skillsManager = new skills_manager_1.SkillsManager();
 program
@@ -20,10 +36,11 @@ program
     .option('-v, --verbose', 'Enable verbose logging');
 // Install command
 program
-    .command('install <source>')
-    .description('Install a skill from URL or local archive file')
+    .command('install [source]')
+    .description('Install a skill from URL or local archive file (no source = search Wiki)')
     .option('-u, --username <username>', 'Wiki username (for wiki URLs)')
     .option('-p, --password <password>', 'Wiki password (not recommended, use interactive input instead)')
+    .option('-w, --wiki-url <url>', 'Wiki base URL (for search)', 'https://sswiki.sigmastar.com.tw:8090')
     .option('--allow-self-signed', 'Allow self-signed SSL certificates (default: true)', true)
     .option('-f, --force', 'Reinstall if skill already exists')
     .option('-g, --global', 'Install to global directory')
@@ -58,9 +75,23 @@ program
         console.log(`AI Tool: ${aiTool}`);
         console.log(`Installing to: ${skillsDir}`);
         console.log('');
-        // Get username/password for wiki URLs
-        let username = options.username || process.env.WIKI_USERNAME || '';
+        // Get username/password for wiki URLs or search
+        // Auto-detect username from system if not provided
+        let username = options.username || process.env.WIKI_USERNAME || os_1.default.userInfo().username;
         let password = options.password || process.env.WIKI_PASSWORD || '';
+        // If no source provided, trigger search flow
+        if (!source) {
+            // Only require password, username is auto-detected
+            if (!password) {
+                password = await promptPassword();
+            }
+            const selectedUrl = await searchAndSelectSkill(username, password, options.wikiUrl, options.allowSelfSigned);
+            if (!selectedUrl) {
+                console.log('No skill selected.');
+                process.exit(0);
+            }
+            source = selectedUrl;
+        }
         // Check if source appears to be a wiki URL
         const needsAuth = source.includes('/download/attachments/') ||
             source.includes('/wiki/download/') ||
@@ -86,16 +117,58 @@ program
             allowSelfSigned: options.allowSelfSigned,
             force: options.force
         });
+        // Handle multi-skill package
+        if (result.isMultiSkill && result.skills) {
+            const selectedSkills = await selectSkillsFromPackage(result.skills);
+            if (selectedSkills.length === 0) {
+                console.log('No skills selected.');
+                process.exit(0);
+            }
+            // Install selected skills
+            const installResults = await installer.installSelectedSkills(selectedSkills, '', // extractDir is already handled in install()
+            {
+                source,
+                skillsDir,
+                username,
+                password,
+                allowSelfSigned: options.allowSelfSigned,
+                force: options.force
+            });
+            // Display results
+            console.log('');
+            let successCount = 0;
+            let failCount = 0;
+            for (const res of installResults) {
+                if (res.success) {
+                    console.log(`✓ Skill "${res.skillName}" installed successfully!`);
+                    console.log(`  Path: ${res.skillPath}`);
+                    successCount++;
+                }
+                else {
+                    console.error(`✗ Failed to install skill: ${res.error}`);
+                    failCount++;
+                }
+            }
+            console.log('');
+            console.log(`Installation complete: ${successCount} succeeded, ${failCount} failed.`);
+            process.exit(failCount > 0 ? 1 : 0);
+        }
+        // Handle single skill result
+        const singleResult = result.singleSkillResult;
+        if (!singleResult) {
+            console.error('✗ Installation failed: No result returned');
+            process.exit(1);
+        }
         console.log('');
-        if (result.success) {
+        if (singleResult.success) {
             console.log(`✓ Skill installed successfully!`);
-            console.log(`  Name: ${result.skillName}`);
-            console.log(`  Path: ${result.skillPath}`);
+            console.log(`  Name: ${singleResult.skillName}`);
+            console.log(`  Path: ${singleResult.skillPath}`);
             process.exit(0);
         }
         else {
             console.error(`✗ Installation failed!`);
-            console.error(`  Error: ${result.error || 'Unknown error'}`);
+            console.error(`  Error: ${singleResult.error || 'Unknown error'}`);
             process.exit(1);
         }
     }
@@ -364,21 +437,94 @@ function promptAiTool() {
         });
     });
 }
-function promptSkillSelection(skills) {
+function selectSkillsFromPackage(skills) {
     return new Promise((resolve) => {
         const rl = readline_1.default.createInterface({
             input: process.stdin,
             output: process.stdout
         });
         console.log('');
-        console.log('Installed skills:');
+        console.log(`${colors.cyan}Multi-skill package detected!${colors.reset}`);
+        console.log(`${colors.cyan}Found ${skills.length} skill(s) in this package:${colors.reset}`);
         console.log('');
+        // Display all skills with colors and separators
         for (let i = 0; i < skills.length; i++) {
             const skill = skills[i];
-            console.log(`  [${i + 1}] ${skill.name}`);
-            console.log(`      ${skill.description}`);
+            // Separator line before each skill
+            console.log(`${colors.dim}${'─'.repeat(60)}${colors.reset}`);
+            // Index and skill name
+            console.log(`${colors.bright}${colors.green}[${i + 1}]${colors.reset} ${colors.bright}${colors.yellow}${skill.name}${colors.reset}`);
+            // Description
+            const lines = skill.description.split('\n');
+            for (const line of lines) {
+                console.log(`${colors.dim}    ${line}${colors.reset}`);
+            }
+            // Relative path in package
+            console.log(`${colors.dim}    Package path: ${skill.relativePath}${colors.reset}`);
+        }
+        // Separator line after last skill
+        console.log(`${colors.dim}${'─'.repeat(60)}${colors.reset}`);
+        console.log('');
+        console.log('Enter the numbers of the skills to install (separated by spaces, e.g., "1 3 5"):');
+        console.log('Press Enter to install all skills:');
+        rl.question('Your choice: ', (answer) => {
+            rl.close();
+            const input = answer.trim();
+            if (!input) {
+                // Install all skills
+                console.log(`Installing all ${skills.length} skills...`);
+                resolve(skills);
+                return;
+            }
+            // Parse the input and extract valid indices
+            const selectedNumbers = input.split(/\s+/).map(s => parseInt(s, 10));
+            const selectedSkills = [];
+            for (const num of selectedNumbers) {
+                if (isNaN(num)) {
+                    console.log(`Skipping invalid number: ${input}`);
+                    continue;
+                }
+                if (num < 1 || num > skills.length) {
+                    console.log(`Skipping out of range number: ${num}`);
+                    continue;
+                }
+                selectedSkills.push(skills[num - 1]);
+            }
+            if (selectedSkills.length === 0) {
+                console.log('No valid skills selected.');
+                resolve([]);
+                return;
+            }
             console.log('');
+            console.log(`Selected skills: ${selectedSkills.map(s => s.name).join(', ')}`);
+            resolve(selectedSkills);
+        });
+    });
+}
+function promptSkillSelection(skills) {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        console.log('');
+        console.log(`${colors.cyan}Installed skills:${colors.reset}`);
+        console.log('');
+        // Display all skills with colors and separators
+        for (let i = 0; i < skills.length; i++) {
+            const skill = skills[i];
+            // Separator line before each skill
+            console.log(`${colors.dim}${'─'.repeat(60)}${colors.reset}`);
+            // Index and skill name
+            console.log(`${colors.bright}${colors.green}[${i + 1}]${colors.reset} ${colors.bright}${colors.yellow}${skill.name}${colors.reset}`);
+            // Description
+            console.log(`${colors.dim}    ${skill.description}${colors.reset}`);
+            // Path
+            console.log(`${colors.dim}    ${skill.path}${colors.reset}`);
         }
+        // Separator line after last skill
+        console.log(`${colors.dim}${'─'.repeat(60)}${colors.reset}`);
+        console.log('');
         console.log('Enter the numbers of the skills to uninstall (separated by spaces, e.g., "1 3 5"):');
         console.log('Press Enter to cancel:');
         rl.question('Your choice: ', (answer) => {
@@ -456,4 +602,46 @@ async function listSkillsFromBothDirectories(aiTool) {
         console.log('No skills installed in either location.');
     }
 }
+function promptUsername() {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question('Wiki username: ', (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function searchAndSelectSkill(username, password, wikiUrl, allowSelfSigned) {
+    const searcher = new wiki_1.WikiSearcher();
+    const selector = new wiki_1.SkillSelector();
+    console.log(`Username: ${username}`);
+    console.log('Searching Wiki for skills...');
+    console.log('');
+    try {
+        // Search for attachments with agent_skill tag
+        const items = await searcher.search({
+            username,
+            password,
+            baseUrl: wikiUrl,
+            allowSelfSigned
+        });
+        if (items.length === 0) {
+            console.log('No skills found.');
+            return null;
+        }
+        // Parse items (fetch comments)
+        const parser = new wiki_1.WikiParser(searcher.httpClientInstance);
+        const parsed = await parser.parseSkillItems(items);
+        // Display and select
+        const selectedUrl = await selector.displayAndSelect(parsed);
+        return selectedUrl;
+    }
+    catch (error) {
+        console.error(`Search failed: ${error.message}`);
+        return null;
+    }
+}
 program.parse();

package/dist/core/logger.js

@@ -65,4 +65,4 @@ class Logger {
     }
 }
 exports.Logger = Logger;
-Logger.globalLevel = 'info';
+Logger.globalLevel = 'error';

package/dist/http/http-client.js

@@ -13,10 +13,9 @@ class HttpClient {
         this.options = options;
         this.logger = new logger_1.Logger('HttpClient');
         this.cookieStore = new Map();
-        // 设置环境变量来忽略证书验证（必须在创建axios实例之前）
+        // 配置axios实例
         this.logger.info(`HTTP Client config: baseUrl=${options.baseUrl}, allowSelfSigned=${options.allowSelfSigned}`);
         if (options.baseUrl.startsWith('https://') && options.allowSelfSigned) {
-            process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
             this.logger.warn('SSL certificate verification disabled for self-signed certificates');
         }
         // 配置axios实例

package/dist/installer/install-service.d.ts

@@ -12,6 +12,17 @@ export interface InstallResult {
     skillPath?: string;
     error?: string;
 }
+export interface SkillInPackage {
+    name: string;
+    description: string;
+    path: string;
+    relativePath: string;
+}
+export interface MultiSkillPackageResult {
+    isMultiSkill: boolean;
+    skills?: SkillInPackage[];
+    singleSkillResult?: InstallResult;
+}
 export declare class InstallService {
     private readonly logger;
     private readonly sourceDetector;
@@ -21,13 +32,22 @@ export declare class InstallService {
     private readonly skillsManager;
     /**
      * Install a skill from a source (URL or local file)
+     * Returns MultiSkillPackageResult to handle both single and multi-skill packages
+     */
+    install(options: InstallOptions): Promise<MultiSkillPackageResult>;
+    /**
+     * Install selected skills from a multi-skill package
+     */
+    installSelectedSkills(skills: SkillInPackage[], extractDir: string, options: InstallOptions): Promise<InstallResult[]>;
+    /**
+     * Find all skill directories in the extracted files
+     * Searches recursively for all directories containing SKILL.md
      */
-    install(options: InstallOptions): Promise<InstallResult>;
+    private findAllSkillDirectories;
     /**
-     * Find the skill directory in the extracted files
-     * The archive may contain a single root directory or have SKILL.md at root
+     * Recursively find all directories containing valid SKILL.md
      */
-    private findSkillDirectory;
+    private findSkillDirectoriesRecursive;
     /**
      * Move a directory from one location to another
      * Handles cross-device moves by copying and then deleting

package/dist/installer/install-service.js

@@ -22,6 +22,7 @@ class InstallService {
     }
     /**
      * Install a skill from a source (URL or local file)
+     * Returns MultiSkillPackageResult to handle both single and multi-skill packages
      */
     async install(options) {
         const tempDir = await (0, promises_1.mkdtemp)((0, path_1.join)((0, os_1.tmpdir)(), 'skill-install-'));
@@ -64,11 +65,30 @@ class InstallService {
             catch (error) {
                 throw new errors_1.WikiError(errors_1.ErrorType.EXTRACTION_FAILED, `Failed to extract archive: ${error.message}`, error);
             }
-            // Find the skill directory (may be the root or a subdirectory)
-            const skillDir = await this.findSkillDirectory(extractDir);
-            if (!skillDir) {
+            // Find all skill directories in the package
+            const skillDirs = await this.findAllSkillDirectories(extractDir);
+            if (skillDirs.length === 0) {
                 throw new errors_1.WikiError(errors_1.ErrorType.INVALID_SKILL, 'No valid skill found in archive. A valid skill must contain SKILL.md with name and description.');
             }
+            // If multiple skills found, return them for user selection
+            if (skillDirs.length > 1) {
+                const skills = [];
+                for (const skillDir of skillDirs) {
+                    const metadata = await this.validator.validateOrThrow(skillDir);
+                    skills.push({
+                        name: metadata.name,
+                        description: metadata.description,
+                        path: skillDir,
+                        relativePath: (0, path_1.relative)(extractDir, skillDir)
+                    });
+                }
+                return {
+                    isMultiSkill: true,
+                    skills
+                };
+            }
+            // Single skill - proceed with installation
+            const skillDir = skillDirs[0];
             // Validate the skill
             const metadata = await this.validator.validateOrThrow(skillDir);
             // Check if already installed
@@ -92,17 +112,23 @@ class InstallService {
             await this.moveDirectory(skillDir, targetPath);
             this.logger.info(`Skill installed successfully: ${metadata.name} -> ${targetPath}`);
             return {
-                success: true,
-                skillName: metadata.name,
-                skillPath: targetPath
+                isMultiSkill: false,
+                singleSkillResult: {
+                    success: true,
+                    skillName: metadata.name,
+                    skillPath: targetPath
+                }
             };
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);
             this.logger.error(`Installation failed: ${errorMsg}`);
             return {
-                success: false,
-                error: errorMsg
+                isMultiSkill: false,
+                singleSkillResult: {
+                    success: false,
+                    error: errorMsg
+                }
             };
         }
         finally {
@@ -116,32 +142,83 @@ class InstallService {
         }
     }
     /**
-     * Find the skill directory in the extracted files
-     * The archive may contain a single root directory or have SKILL.md at root
+     * Install selected skills from a multi-skill package
+     */
+    async installSelectedSkills(skills, extractDir, options) {
+        const results = [];
+        const targetSkillsDir = this.skillsManager.getEffectiveSkillsDir(options.skillsDir);
+        await (0, promises_1.mkdir)(targetSkillsDir, { recursive: true });
+        for (const skill of skills) {
+            try {
+                const targetPath = (0, path_1.join)(targetSkillsDir, skill.name);
+                // Check if already installed
+                if (!options.force && await this.skillsManager.isInstalled(skill.name, options.skillsDir)) {
+                    results.push({
+                        success: false,
+                        error: `Skill "${skill.name}" is already installed. Use --force to reinstall.`
+                    });
+                    continue;
+                }
+                // If the skill already exists and force is true, remove it first
+                if (options.force) {
+                    try {
+                        await (0, promises_1.rm)(targetPath, { recursive: true, force: true });
+                    }
+                    catch {
+                        // Ignore if directory doesn't exist
+                    }
+                }
+                // Move the skill directory to the final location
+                await this.moveDirectory(skill.path, targetPath);
+                this.logger.info(`Skill installed successfully: ${skill.name} -> ${targetPath}`);
+                results.push({
+                    success: true,
+                    skillName: skill.name,
+                    skillPath: targetPath
+                });
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Failed to install ${skill.name}: ${errorMsg}`);
+                results.push({
+                    success: false,
+                    error: errorMsg
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Find all skill directories in the extracted files
+     * Searches recursively for all directories containing SKILL.md
      */
-    async findSkillDirectory(extractDir) {
-        // First, check if SKILL.md exists at the root
-        const entries = await (0, promises_1.readdir)(extractDir, { withFileTypes: true });
-        // Check for SKILL.md at root level
-        const hasSkillMdAtRoot = entries.some(e => e.name === 'SKILL.md');
-        if (hasSkillMdAtRoot) {
-            const isValid = await this.validator.validate(extractDir);
+    async findAllSkillDirectories(extractDir) {
+        const skillDirs = [];
+        await this.findSkillDirectoriesRecursive(extractDir, skillDirs);
+        return skillDirs;
+    }
+    /**
+     * Recursively find all directories containing valid SKILL.md
+     */
+    async findSkillDirectoriesRecursive(dir, results) {
+        const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+        // Check if current directory has SKILL.md
+        const hasSkillMd = entries.some(e => e.name === 'SKILL.md');
+        if (hasSkillMd) {
+            const isValid = await this.validator.validate(dir);
             if (isValid.valid) {
-                return extractDir;
+                results.push(dir);
+                // Don't recurse into a valid skill directory
+                return;
             }
         }
-        // Check subdirectories
+        // Recurse into subdirectories
         for (const entry of entries) {
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            const subDirPath = (0, path_1.join)(extractDir, entry.name);
-            const isValid = await this.validator.validate(subDirPath);
-            if (isValid.valid) {
-                return subDirPath;
+            if (entry.isDirectory()) {
+                const subDirPath = (0, path_1.join)(dir, entry.name);
+                await this.findSkillDirectoriesRecursive(subDirPath, results);
             }
         }
-        return null;
     }
     /**
      * Move a directory from one location to another

package/dist/wiki/index.d.ts

@@ -0,0 +1,3 @@
+export { WikiSearcher, WikiSkillItem, SearchOptions } from './wiki-searcher';
+export { WikiParser, ParsedSkillItem } from './wiki-parser';
+export { SkillSelector } from './skill-selector';

package/dist/wiki/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillSelector = exports.WikiParser = exports.WikiSearcher = void 0;
+var wiki_searcher_1 = require("./wiki-searcher");
+Object.defineProperty(exports, "WikiSearcher", { enumerable: true, get: function () { return wiki_searcher_1.WikiSearcher; } });
+var wiki_parser_1 = require("./wiki-parser");
+Object.defineProperty(exports, "WikiParser", { enumerable: true, get: function () { return wiki_parser_1.WikiParser; } });
+var skill_selector_1 = require("./skill-selector");
+Object.defineProperty(exports, "SkillSelector", { enumerable: true, get: function () { return skill_selector_1.SkillSelector; } });

package/dist/wiki/skill-selector.d.ts

@@ -0,0 +1,13 @@
+import { ParsedSkillItem } from './wiki-parser';
+export declare class SkillSelector {
+    private readonly logger;
+    /**
+     * Display skill list and wait for user selection
+     * Returns the download URL of selected skill, or null if cancelled
+     */
+    displayAndSelect(items: ParsedSkillItem[]): Promise<string | null>;
+    /**
+     * Prompt user to select a skill from the list
+     */
+    private promptChoice;
+}

package/dist/wiki/skill-selector.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillSelector = void 0;
+const readline_1 = __importDefault(require("readline"));
+const logger_1 = require("../core/logger");
+// Color codes for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m'
+};
+class SkillSelector {
+    constructor() {
+        this.logger = new logger_1.Logger('SkillSelector');
+    }
+    /**
+     * Display skill list and wait for user selection
+     * Returns the download URL of selected skill, or null if cancelled
+     */
+    async displayAndSelect(items) {
+        if (items.length === 0) {
+            this.logger.info('No skills found to display.');
+            return null;
+        }
+        console.log('');
+        console.log(`${colors.cyan}Found ${items.length} skill(s):${colors.reset}`);
+        console.log('');
+        // Display all skills
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            // Add separator line before each skill
+            console.log(`${colors.dim}${'─'.repeat(60)}${colors.reset}`);
+            // Index with color
+            console.log(`${colors.bright}${colors.green}[${i + 1}]${colors.reset} ${colors.bright}${colors.yellow}${item.name}${colors.reset} ${colors.dim}${colors.gray}${item.pageUrl}${colors.reset}`);
+            // Display comment (may be multiline)
+            if (item.description) {
+                const lines = item.description.split('\n');
+                for (const line of lines) {
+                    console.log(`${colors.dim}    ${line}${colors.reset}`);
+                }
+            }
+        }
+        // Add separator line after the last skill
+        console.log(`${colors.dim}${'─'.repeat(60)}${colors.reset}`);
+        console.log('');
+        // Prompt for selection
+        const choice = await this.promptChoice(items.length);
+        if (choice === null) {
+            return null;
+        }
+        const selected = items[choice];
+        this.logger.info(`Selected: ${selected.name}`);
+        return selected.downloadUrl;
+    }
+    /**
+     * Prompt user to select a skill from the list
+     */
+    promptChoice(max) {
+        return new Promise((resolve) => {
+            const rl = readline_1.default.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            rl.question(`Select skill to install [1-${max}] (0 to cancel): `, (answer) => {
+                rl.close();
+                const trimmed = answer.trim();
+                if (trimmed === '') {
+                    console.log('No selection made.');
+                    resolve(null);
+                    return;
+                }
+                const num = parseInt(trimmed, 10);
+                if (isNaN(num)) {
+                    console.log('Invalid input. Please enter a number.');
+                    resolve(null);
+                    return;
+                }
+                if (num < 0 || num > max) {
+                    console.log(`Invalid selection. Please enter a number between 0 and ${max}.`);
+                    resolve(null);
+                    return;
+                }
+                if (num === 0) {
+                    console.log('Cancelled.');
+                    resolve(null);
+                    return;
+                }
+                resolve(num - 1); // Convert to 0-based index
+            });
+        });
+    }
+}
+exports.SkillSelector = SkillSelector;

package/dist/wiki/wiki-parser.d.ts

@@ -0,0 +1,26 @@
+import { HttpClient } from '../http/http-client';
+import { WikiSkillItem } from './wiki-searcher';
+export interface ParsedSkillItem extends WikiSkillItem {
+    description: string;
+}
+export declare class WikiParser {
+    private httpClient;
+    private readonly logger;
+    constructor(httpClient: HttpClient);
+    /**
+     * Get attachment comment/description from the attachment metadata
+     */
+    getAttachmentComments(attachmentId: string): Promise<string>;
+    /**
+     * Get actual replies/comments on the attachment
+     */
+    private getAttachmentReplies;
+    /**
+     * Parse all skill items and fetch their comments
+     */
+    parseSkillItems(items: WikiSkillItem[]): Promise<ParsedSkillItem[]>;
+    /**
+     * Extract plain text description from HTML comments
+     */
+    private extractDescription;
+}

package/dist/wiki/wiki-parser.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WikiParser = void 0;
+const logger_1 = require("../core/logger");
+class WikiParser {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.logger = new logger_1.Logger('WikiParser');
+    }
+    /**
+     * Get attachment comment/description from the attachment metadata
+     */
+    async getAttachmentComments(attachmentId) {
+        try {
+            this.logger.info(`Fetching attachment details for ID: ${attachmentId}`);
+            // Get attachment details with metadata and extensions
+            const response = await this.httpClient.get(`/rest/api/content/${attachmentId}?expand=metadata,extensions`);
+            this.logger.debug(`Attachment API response status: ${response.status}`);
+            // Try to get comment from metadata or extensions
+            const comment = response.data?.metadata?.comment ||
+                response.data?.extensions?.comment ||
+                '';
+            if (comment) {
+                this.logger.info(`Found comment for attachment ${attachmentId}: ${comment}`);
+                return comment;
+            }
+            this.logger.debug(`No comment found in attachment metadata for: ${attachmentId}`);
+            // Fallback: try to get actual comments on the attachment
+            return await this.getAttachmentReplies(attachmentId);
+        }
+        catch (error) {
+            this.logger.error(`Failed to fetch attachment details for ${attachmentId}: ${error.message}`);
+            return '';
+        }
+    }
+    /**
+     * Get actual replies/comments on the attachment
+     */
+    async getAttachmentReplies(attachmentId) {
+        try {
+            const expandParams = 'body.view,body.export_view,body.storage';
+            const response = await this.httpClient.get(`/rest/api/content/${attachmentId}/child/comment?expand=${expandParams}`);
+            if (!response.data?.results?.length) {
+                return '';
+            }
+            const comments = response.data.results
+                .map((c) => {
+                return c.body?.view?.value ||
+                    c.body?.export_view?.value ||
+                    c.body?.storage?.value ||
+                    '';
+            })
+                .filter(Boolean)
+                .join('\n---\n');
+            this.logger.info(`Found ${response.data.results.length} comment(s) for attachment: ${attachmentId}`);
+            return comments;
+        }
+        catch (error) {
+            this.logger.debug(`Failed to fetch attachment replies: ${error.message}`);
+            return '';
+        }
+    }
+    /**
+     * Parse all skill items and fetch their comments
+     */
+    async parseSkillItems(items) {
+        const results = [];
+        this.logger.info(`Parsing ${items.length} skill item(s)...`);
+        for (const item of items) {
+            const comments = await this.getAttachmentComments(item.id);
+            results.push({
+                ...item,
+                description: this.extractDescription(comments)
+            });
+        }
+        return results;
+    }
+    /**
+     * Extract plain text description from HTML comments
+     */
+    extractDescription(htmlComments) {
+        if (!htmlComments || htmlComments.trim() === '') {
+            return 'No description available.';
+        }
+        // Decode HTML entities
+        let text = htmlComments
+            .replace(/ /g, ' ')
+            .replace(/&/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'")
+            .replace(/&apos;/g, "'");
+        // Remove HTML tags
+        text = text.replace(/<[^>]*>/g, '');
+        // Clean up whitespace
+        text = text.replace(/\s+/g, ' ').trim();
+        // Limit to 200 characters
+        if (text.length > 200) {
+            text = text.substring(0, 197) + '...';
+        }
+        return text || 'No description available.';
+    }
+}
+exports.WikiParser = WikiParser;

package/dist/wiki/wiki-searcher.d.ts

@@ -0,0 +1,33 @@
+import { HttpClient } from '../http/http-client';
+export interface WikiSkillItem {
+    id: string;
+    name: string;
+    downloadUrl: string;
+    containerId: string;
+    pageUrl: string;
+}
+export interface SearchOptions {
+    username: string;
+    password: string;
+    baseUrl?: string;
+    allowSelfSigned?: boolean;
+}
+export declare class WikiSearcher {
+    private readonly logger;
+    private httpClient;
+    private authService;
+    get httpClientInstance(): HttpClient;
+    constructor();
+    /**
+     * Search for attachments with agent_skill tag
+     */
+    search(options: SearchOptions): Promise<WikiSkillItem[]>;
+    /**
+     * Filter search results by file extension
+     */
+    private filterByExtension;
+    /**
+     * Build full download URL from API response
+     */
+    private buildDownloadUrl;
+}

package/dist/wiki/wiki-searcher.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WikiSearcher = void 0;
+const http_client_1 = require("../http/http-client");
+const auth_service_1 = require("../auth/auth-service");
+const logger_1 = require("../core/logger");
+const errors_1 = require("../core/errors");
+const ALLOWED_EXTENSIONS = ['.tar.gz', '.tgz', '.zip'];
+class WikiSearcher {
+    get httpClientInstance() {
+        return this.httpClient;
+    }
+    constructor() {
+        this.logger = new logger_1.Logger('WikiSearcher');
+        // Will be initialized in search method
+        this.httpClient = null;
+        this.authService = null;
+    }
+    /**
+     * Search for attachments with agent_skill tag
+     */
+    async search(options) {
+        // Determine base URL from environment or use default
+        const baseUrl = options.baseUrl || process.env.WIKI_BASE_URL || '';
+        if (!baseUrl) {
+            throw new errors_1.WikiError(errors_1.ErrorType.INVALID_INPUT, 'Wiki base URL is required. Set WIKI_BASE_URL environment variable or use --wiki-url option.');
+        }
+        // Initialize HTTP client and auth service
+        this.httpClient = new http_client_1.HttpClient({
+            baseUrl,
+            allowSelfSigned: options.allowSelfSigned ?? true
+        });
+        this.authService = new auth_service_1.AuthService(this.httpClient, {
+            baseUrl,
+            username: options.username,
+            password: options.password
+        });
+        // Authenticate
+        this.logger.info('Authenticating to Wiki...');
+        await this.authService.ensureAuthenticated();
+        this.logger.info('Authentication successful');
+        // Search for attachments with agent_skill label
+        this.logger.info('Searching for attachments with agent_skill tag...');
+        const response = await this.httpClient.get('/rest/api/content/search?cql=type=attachment+and+label=agent_skill&expand=container,version');
+        if (!response.data?.results) {
+            this.logger.warn('No results found');
+            return [];
+        }
+        // Filter by allowed extensions
+        const filtered = this.filterByExtension(response.data.results, ALLOWED_EXTENSIONS);
+        this.logger.info(`Found ${filtered.length} skill(s) matching criteria`);
+        return filtered;
+    }
+    /**
+     * Filter search results by file extension
+     */
+    filterByExtension(results, extensions) {
+        const filtered = [];
+        if (!results) {
+            return filtered;
+        }
+        for (const item of results) {
+            const filename = item.title || '';
+            // Check if filename ends with any allowed extension
+            const hasAllowedExtension = extensions.some(ext => filename.endsWith(ext));
+            if (hasAllowedExtension) {
+                const baseUrl = this.httpClient.getBaseURL();
+                filtered.push({
+                    id: item.id,
+                    name: filename,
+                    downloadUrl: this.buildDownloadUrl(baseUrl, item),
+                    containerId: item.container?.id || '',
+                    pageUrl: item._links?.webui ? `${baseUrl}${item._links.webui}` : ''
+                });
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Build full download URL from API response
+     */
+    buildDownloadUrl(baseUrl, item) {
+        // Try to use download link from API
+        if (item._links?.download) {
+            const downloadPath = item._links.download;
+            if (downloadPath.startsWith('http')) {
+                return downloadPath;
+            }
+            return `${baseUrl}${downloadPath}`;
+        }
+        // Fallback: construct URL from attachment info
+        if (item.container?.id && item.id) {
+            return `${baseUrl}/download/attachments/${item.container.id}/${encodeURIComponent(item.title)}`;
+        }
+        throw new errors_1.WikiError(errors_1.ErrorType.INVALID_INPUT, `Cannot build download URL for attachment: ${item.title}`);
+    }
+}
+exports.WikiSearcher = WikiSearcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sstar/skill-install",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Agent Skill installation tool - download, extract, validate, and install skills for Claude Code and Codex",
   "main": "dist/index.js",
   "bin": {