incur 0.4.2 → 0.4.4

package/src/SyncSkills.ts

@@ -2,6 +2,7 @@ import fsSync from 'node:fs'
 import fs from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
+import { parse as yamlParse } from 'yaml'
 
 import { formatExamples } from './Cli.js'
 import * as Agents from './internal/agents.js'
@@ -30,9 +31,8 @@ export async function sync(
         : path.join(tmpDir, 'SKILL.md')
       await fs.mkdir(path.dirname(filePath), { recursive: true })
       await fs.writeFile(filePath, `${file.content}\n`)
-      const nameMatch = file.content.match(/^name:\s*(.+)$/m)
-      const descMatch = file.content.match(/^description:\s*(.+)$/m)
-      skills.push({ name: nameMatch?.[1] ?? (file.dir || name), description: descMatch?.[1] })
+      const meta = parseFrontmatter(file.content)
+      skills.push({ name: meta.name ?? (file.dir || name), description: meta.description })
     }
 
     // Include additional SKILL.md files matched by glob patterns
@@ -42,16 +42,14 @@ export async function sync(
         for await (const match of fs.glob(globPattern, { cwd })) {
           try {
             const content = await fs.readFile(path.resolve(cwd, match), 'utf8')
-            const nameMatch = content.match(/^name:\s*(.+)$/m)
+            const meta = parseFrontmatter(content)
             const skillName =
-              pattern === '_root' ? (nameMatch?.[1] ?? name) : path.basename(path.dirname(match))
+              pattern === '_root' ? (meta.name ?? name) : path.basename(path.dirname(match))
             const dest = path.join(tmpDir, skillName, 'SKILL.md')
             await fs.mkdir(path.dirname(dest), { recursive: true })
             await fs.writeFile(dest, content)
-            if (!skills.some((s) => s.name === skillName)) {
-              const descMatch = content.match(/^description:\s*(.+)$/m)
-              skills.push({ name: skillName, description: descMatch?.[1], external: true })
-            }
+            if (!skills.some((s) => s.name === skillName))
+              skills.push({ name: skillName, description: meta.description, external: true })
           } catch {}
         }
       }
@@ -148,12 +146,11 @@ export async function list(
   const installed = readInstalledSkills(name, { cwd })
 
   for (const file of files) {
-    const nameMatch = file.content.match(/^name:\s*(.+)$/m)
-    const descMatch = file.content.match(/^description:\s*(.+)$/m)
-    const skillName = nameMatch?.[1] ?? (file.dir || name)
+    const meta = parseFrontmatter(file.content)
+    const skillName = meta.name ?? (file.dir || name)
     skills.push({
       name: skillName,
-      description: descMatch?.[1],
+      description: meta.description,
       installed: installed.has(skillName),
     })
   }
@@ -165,14 +162,12 @@ export async function list(
       for await (const match of fs.glob(globPattern, { cwd })) {
         try {
           const content = await fs.readFile(path.resolve(cwd, match), 'utf8')
-          const nameMatch = content.match(/^name:\s*(.+)$/m)
-          const skillName =
-            pattern === '_root' ? (nameMatch?.[1] ?? name) : path.basename(path.dirname(match))
+          const meta = parseFrontmatter(content)
+          const skillName = pattern === '_root' ? (meta.name ?? name) : path.basename(path.dirname(match))
           if (!skills.some((s) => s.name === skillName)) {
-            const descMatch = content.match(/^description:\s*(.+)$/m)
             skills.push({
               name: skillName,
-              description: descMatch?.[1],
+              description: meta.description,
               installed: installed.has(skillName),
             })
           }
@@ -284,6 +279,15 @@ function collectEntries(
   return result.sort((a, b) => (a.name ?? '').localeCompare(b.name ?? ''))
 }
 
+function parseFrontmatter(content: string): { description?: string | undefined; name?: string | undefined } {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+  if (!match) return {}
+
+  const meta = yamlParse(match[1]!)
+  if (!meta || typeof meta !== 'object') return {}
+  return meta as { description?: string | undefined; name?: string | undefined }
+}
+
 /** Resolves the package root from the executing bin script (`process.argv[1]`). Walks up from the bin's directory looking for `package.json`. Falls back to `process.cwd()`. */
 function resolvePackageRoot(): string {
   const bin = process.argv[1]

package/src/internal/command.ts

@@ -350,9 +350,16 @@ export type CommandMeta<options extends z.ZodObject<any> | undefined = undefined
   options?: options | undefined
 }
 
+/** @internal Metadata for a built-in subcommand. */
+type BuiltinSubcommandMeta<options extends z.ZodObject<any> | undefined = undefined> =
+  CommandMeta<options> & {
+    /** Alternative names for this built-in subcommand. */
+    aliases?: string[] | undefined
+  }
+
 /** @internal Creates a builtin subcommand with typesafe alias inference. */
 function subcommand<const options extends z.ZodObject<any> | undefined = undefined>(
-  def: CommandMeta<options> & { name: string },
+  def: BuiltinSubcommandMeta<options> & { name: string },
 ) {
   return def
 }
@@ -425,6 +432,7 @@ export const builtinCommands = [
       }),
       subcommand({
         name: 'list',
+        aliases: ['ls'],
         description: 'List skills',
       }),
     ],
@@ -435,7 +443,7 @@ export const builtinCommands = [
   args?: z.ZodObject<any> | undefined
   description: string
   hint?: ((name: string) => string) | undefined
-  subcommands?: (CommandMeta<z.ZodObject<any>> & { name: string })[] | undefined
+  subcommands?: (BuiltinSubcommandMeta<z.ZodObject<any>> & { name: string })[] | undefined
 }[]
 
 /** @internal Finds a builtin command by its name or alias. */
@@ -443,6 +451,11 @@ export function findBuiltin(token: string) {
   return builtinCommands.find((b) => b.name === token || b.aliases?.includes(token))
 }
 
+/** @internal Finds a builtin subcommand by its name or alias. */
+export function findBuiltinSubcommand(builtin: (typeof builtinCommands)[number], token: string) {
+  return builtin.subcommands?.find((sub) => sub.name === token || sub.aliases?.includes(token))
+}
+
 /** @internal Checks if a token matches a builtin command by name or alias. */
 export function isBuiltin(token: string) {
   return builtinCommands.some((b) => b.name === token || b.aliases?.includes(token))