skillsets 0.6.0 → 0.6.2

package/dist/commands/init.d.ts

@@ -1,5 +1,11 @@
 interface InitOptions {
     yes?: boolean;
+    name?: string;
+    description?: string;
+    handle?: string;
+    authorUrl?: string;
+    productionUrl?: string;
+    tags?: string;
 }
-export declare function init(_options: InitOptions): Promise<void>;
+export declare function init(options: InitOptions): Promise<void>;
 export {};

package/dist/commands/init.js

@@ -156,6 +156,18 @@ function copyDirRecursive(src, dest, exclusions) {
         }
     }
 }
+/** Check if a directory tree contains any support stack marker file */
+function hasMarkerDeep(dir) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (COPY_EXCLUSIONS.has(entry.name))
+            continue;
+        if (entry.isFile() && SUPPORT_STACK_MARKERS.includes(entry.name))
+            return true;
+        if (entry.isDirectory() && hasMarkerDeep(join(dir, entry.name)))
+            return true;
+    }
+    return false;
+}
 /** Scan top-level directories for self-contained support stacks */
 function detectSupportStacks(cwd) {
     const stacks = [];
@@ -164,14 +176,13 @@ function detectSupportStacks(cwd) {
             continue;
         if (entry.name.startsWith('.') || SCAN_SKIP.has(entry.name))
             continue;
-        const dirEntries = readdirSync(join(cwd, entry.name));
-        if (dirEntries.some(f => SUPPORT_STACK_MARKERS.includes(f))) {
+        if (hasMarkerDeep(join(cwd, entry.name))) {
             stacks.push(entry.name + '/');
         }
     }
     return stacks;
 }
-export async function init(_options) {
+export async function init(options) {
     console.log(chalk.blue('\n📦 Initialize a new skillset submission\n'));
     // 1. Verify gh CLI is available and authenticated
     try {
@@ -210,90 +221,147 @@ export async function init(_options) {
     }
     const cwd = process.cwd();
     // Check if already initialized
+    const hasAllFlags = options.name && options.description && options.handle
+        && options.productionUrl && options.tags;
     if (existsSync(join(cwd, 'skillset.yaml'))) {
-        console.log(chalk.yellow('⚠ skillset.yaml already exists in this directory.'));
-        const overwrite = await confirm({
-            message: 'Overwrite existing files?',
-            default: false,
-        });
-        if (!overwrite) {
-            console.log(chalk.gray('Aborted.'));
-            return;
+        if (hasAllFlags) {
+            console.log(chalk.yellow('⚠ skillset.yaml already exists — overwriting (flags provided).'));
         }
-    }
-    // Gather information
-    const name = await input({
-        message: 'Skillset name (alphanumeric, hyphens, underscores):',
-        validate: (value) => {
-            if (!/^[A-Za-z0-9_-]+$/.test(value)) {
-                return 'Name must be alphanumeric with hyphens/underscores only';
-            }
-            if (value.length < 1 || value.length > 100) {
-                return 'Name must be 1-100 characters';
-            }
-            return true;
-        },
-    });
-    const description = await input({
-        message: 'Description (10-200 characters):',
-        validate: (value) => {
-            if (value.length < 10 || value.length > 200) {
-                return 'Description must be 10-200 characters';
-            }
-            return true;
-        },
-    });
-    const authorHandle = await input({
-        message: 'GitHub handle (e.g., @username):',
-        default: `@${login}`,
-        validate: (value) => {
-            if (!/^@[A-Za-z0-9_-]+$/.test(value)) {
-                return 'Handle must start with @ followed by alphanumeric characters';
+        else {
+            console.log(chalk.yellow('⚠ skillset.yaml already exists in this directory.'));
+            const overwrite = await confirm({
+                message: 'Overwrite existing files?',
+                default: false,
+            });
+            if (!overwrite) {
+                console.log(chalk.gray('Aborted.'));
+                return;
             }
-            return true;
-        },
-    });
-    const authorUrl = await input({
-        message: 'Author URL (GitHub profile or website):',
-        default: `https://github.com/${authorHandle.slice(1)}`,
-        validate: (value) => {
-            try {
-                new URL(value);
+        }
+    }
+    // Gather information — skip prompts when flags are provided
+    let name;
+    let description;
+    let authorHandle;
+    let authorUrl;
+    let productionUrl;
+    let tags;
+    if (hasAllFlags) {
+        name = options.name;
+        description = options.description;
+        authorHandle = options.handle.startsWith('@') ? options.handle : `@${options.handle}`;
+        authorUrl = options.authorUrl || `https://github.com/${authorHandle.slice(1)}`;
+        productionUrl = options.productionUrl;
+        tags = options.tags.split(',').map((t) => t.trim());
+        // Validate
+        if (!/^[A-Za-z0-9_-]+$/.test(name) || name.length < 1 || name.length > 100) {
+            throw new Error('Name must be 1-100 alphanumeric characters with hyphens/underscores');
+        }
+        if (description.length < 10 || description.length > 200) {
+            throw new Error('Description must be 10-200 characters');
+        }
+        if (!/^@[A-Za-z0-9_-]+$/.test(authorHandle)) {
+            throw new Error('Handle must start with @ followed by alphanumeric characters');
+        }
+        try {
+            new URL(authorUrl);
+        }
+        catch {
+            throw new Error(`Invalid author URL: ${authorUrl}`);
+        }
+        try {
+            new URL(productionUrl);
+        }
+        catch {
+            throw new Error(`Invalid production URL: ${productionUrl}`);
+        }
+        if (tags.length < 1 || tags.length > 10)
+            throw new Error('Must have 1-10 tags');
+        for (const tag of tags) {
+            if (!/^[a-z0-9-]+$/.test(tag))
+                throw new Error(`Tag "${tag}" must be lowercase alphanumeric with hyphens`);
+        }
+        console.log(chalk.green(`\n✓ Using provided values:`));
+        console.log(`  Name: ${name}`);
+        console.log(`  Description: ${description}`);
+        console.log(`  Handle: ${authorHandle}`);
+        console.log(`  Production: ${productionUrl}`);
+        console.log(`  Tags: ${tags.join(', ')}`);
+    }
+    else {
+        name = await input({
+            message: 'Skillset name (alphanumeric, hyphens, underscores):',
+            validate: (value) => {
+                if (!/^[A-Za-z0-9_-]+$/.test(value)) {
+                    return 'Name must be alphanumeric with hyphens/underscores only';
+                }
+                if (value.length < 1 || value.length > 100) {
+                    return 'Name must be 1-100 characters';
+                }
                 return true;
-            }
-            catch {
-                return 'Must be a valid URL';
-            }
-        },
-    });
-    const productionUrl = await input({
-        message: 'Production URL (live deployment, repo, or case study):',
-        validate: (value) => {
-            try {
-                new URL(value);
+            },
+        });
+        description = await input({
+            message: 'Description (10-200 characters):',
+            validate: (value) => {
+                if (value.length < 10 || value.length > 200) {
+                    return 'Description must be 10-200 characters';
+                }
                 return true;
-            }
-            catch {
-                return 'Must be a valid URL';
-            }
-        },
-    });
-    const tagsInput = await input({
-        message: 'Tags (comma-separated, lowercase, e.g., sdlc,planning,multi-agent):',
-        validate: (value) => {
-            const tags = value.split(',').map((t) => t.trim());
-            if (tags.length < 1 || tags.length > 10) {
-                return 'Must have 1-10 tags';
-            }
-            for (const tag of tags) {
-                if (!/^[a-z0-9-]+$/.test(tag)) {
-                    return `Tag "${tag}" must be lowercase alphanumeric with hyphens only`;
+            },
+        });
+        authorHandle = await input({
+            message: 'GitHub handle (e.g., @username):',
+            default: `@${login}`,
+            validate: (value) => {
+                if (!/^@[A-Za-z0-9_-]+$/.test(value)) {
+                    return 'Handle must start with @ followed by alphanumeric characters';
                 }
-            }
-            return true;
-        },
-    });
-    const tags = tagsInput.split(',').map((t) => t.trim());
+                return true;
+            },
+        });
+        authorUrl = await input({
+            message: 'Author URL (GitHub profile or website):',
+            default: `https://github.com/${authorHandle.slice(1)}`,
+            validate: (value) => {
+                try {
+                    new URL(value);
+                    return true;
+                }
+                catch {
+                    return 'Must be a valid URL';
+                }
+            },
+        });
+        productionUrl = await input({
+            message: 'Production URL (live deployment, repo, or case study):',
+            validate: (value) => {
+                try {
+                    new URL(value);
+                    return true;
+                }
+                catch {
+                    return 'Must be a valid URL';
+                }
+            },
+        });
+        const tagsInput = await input({
+            message: 'Tags (comma-separated, lowercase, e.g., sdlc,planning,multi-agent):',
+            validate: (value) => {
+                const t = value.split(',').map((s) => s.trim());
+                if (t.length < 1 || t.length > 10) {
+                    return 'Must have 1-10 tags';
+                }
+                for (const tag of t) {
+                    if (!/^[a-z0-9-]+$/.test(tag)) {
+                        return `Tag "${tag}" must be lowercase alphanumeric with hyphens only`;
+                    }
+                }
+                return true;
+            },
+        });
+        tags = tagsInput.split(',').map((t) => t.trim());
+    }
     // Auto-detect existing files — core skillset files and primitives
     const coreFiles = [
         'CLAUDE.md', 'README.md', 'QUICKSTART.md',
@@ -316,10 +384,16 @@ export async function init(_options) {
             console.log(chalk.green('\n✓ Detected support stacks:'));
             detectedStacks.forEach((f) => console.log(`  - ${f}`));
         }
-        filesToCopy = await checkbox({
-            message: 'Select files to copy to content/:',
-            choices: allDetected.map((f) => ({ name: f, value: f, checked: true })),
-        });
+        if (hasAllFlags) {
+            filesToCopy = allDetected;
+            console.log(chalk.green('\n✓ Auto-selecting all detected files'));
+        }
+        else {
+            filesToCopy = await checkbox({
+                message: 'Select files to copy to content/:',
+                choices: allDetected.map((f) => ({ name: f, value: f, checked: true })),
+            });
+        }
     }
     // Create structure
     const spinner = ora('Creating skillset structure...').start();

package/dist/index.js

@@ -53,6 +53,12 @@ program
     .command('init')
     .description('Initialize a new skillset submission')
     .option('-y, --yes', 'Accept defaults without prompting')
+    .option('--name <name>', 'Skillset name')
+    .option('--description <desc>', 'Description (10-200 chars)')
+    .option('--handle <handle>', 'GitHub handle (e.g., @username)')
+    .option('--author-url <url>', 'Author URL')
+    .option('--production-url <url>', 'Production URL')
+    .option('--tags <tags>', 'Comma-separated tags')
     .action(run(init));
 program
     .command('audit')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillsets",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "CLI tool for discovering and installing verified skillsets",
   "type": "module",
   "bin": {