incur 0.4.8 → 0.4.9

package/src/SyncMcp.test.ts

@@ -123,6 +123,95 @@ test('register with agents: ["amp"] skips add-mcp', async () => {
   expect(result.agents).toEqual(['Amp'])
 })
 
+test('register handles quoted command paths with spaces', async () => {
+  const { execFile } = await import('node:child_process')
+  vi.mocked(execFile).mockClear()
+
+  const result = await register('my-cli', {
+    command: '"/path/to my/cli" --mcp',
+    agents: ['amp'],
+  })
+
+  expect(result.agents).toEqual(['Amp'])
+
+  const configPath = join(fakeHome!, '.config', 'amp', 'settings.json')
+  const config = JSON.parse(readFileSync(configPath, 'utf-8'))
+  expect(config['amp.mcpServers']['my-cli']).toEqual({
+    command: '/path/to my/cli',
+    args: ['--mcp'],
+  })
+})
+
+test('register uses bare name for global binary installs', async () => {
+  process.argv[1] = '/usr/local/bin/my-cli'
+
+  const { execFile } = await import('node:child_process')
+  vi.mocked(execFile).mockClear()
+
+  const result = await register('my-cli', { agents: ['amp'] })
+
+  expect(result.command).toBe('my-cli --mcp')
+
+  const configPath = join(fakeHome!, '.config', 'amp', 'settings.json')
+  const config = JSON.parse(readFileSync(configPath, 'utf-8'))
+  expect(config['amp.mcpServers']['my-cli']).toEqual({
+    command: 'my-cli',
+    args: ['--mcp'],
+  })
+})
+
+test('register uses runner for source entrypoints outside node_modules', async () => {
+  process.argv[1] = join(tmp, 'dist', 'bin.js')
+
+  const { execFile } = await import('node:child_process')
+  vi.mocked(execFile).mockClear()
+
+  const result = await register('my-cli', { agents: ['amp'] })
+
+  expect(result.command).toMatch(/^(npx|pnpx|bunx)\s/)
+  expect(result.command).toContain('my-cli --mcp')
+})
+
+test('register uses bare name for global package entrypoints under node_modules', async () => {
+  process.argv[1] = join(tmp, 'global', 'node_modules', 'my-cli', 'dist', 'bin.js')
+
+  const { execFile } = await import('node:child_process')
+  vi.mocked(execFile).mockClear()
+
+  const result = await register('my-cli', { agents: ['amp'] })
+
+  expect(result.command).toBe('my-cli --mcp')
+})
+
+test('register uses runner for project dev dependency entrypoints under node_modules', async () => {
+  writeFileSync(
+    join(tmp, 'package.json'),
+    JSON.stringify({ devDependencies: { 'my-cli': '1.0.0' } }),
+  )
+  process.argv[1] = join(tmp, 'node_modules', 'my-cli', 'dist', 'bin.js')
+
+  const { execFile } = await import('node:child_process')
+  vi.mocked(execFile).mockClear()
+
+  const result = await register('my-cli', { agents: ['amp'] })
+
+  expect(result.command).toMatch(/^(npx|pnpx|bunx)\s/)
+  expect(result.command).toContain('my-cli --mcp')
+})
+
+test('register uses runner for node_modules installs', async () => {
+  process.argv[1] = join(tmp, 'node_modules', '.bin', 'my-cli')
+
+  const { execFile } = await import('node:child_process')
+  vi.mocked(execFile).mockClear()
+
+  const result = await register('my-cli', { agents: ['amp'] })
+
+  // Should include a runner prefix (npx, pnpx, or bunx)
+  expect(result.command).toMatch(/^(npx|pnpx|bunx)\s/)
+  expect(result.command).toContain('--mcp')
+})
+
 test('register writes amp config to existing settings', async () => {
   const configDir = join(fakeHome!, '.config', 'amp')
   mkdirSync(configDir, { recursive: true })

package/src/SyncMcp.ts

@@ -11,7 +11,7 @@ export async function register(
   options: register.Options = {},
 ): Promise<register.Result> {
   const runner = detectRunner()
-  const command = options.command ?? `${runner} ${detectPackageSpecifier(name)} --mcp`
+  const command = options.command ?? defaultCommand(name, runner)
   const targetAgents = options.agents ?? []
   const ampOnly = targetAgents.length === 1 && targetAgents[0] === 'amp'
 
@@ -64,7 +64,7 @@ function registerAmp(name: string, command: string): boolean {
     }
   }
 
-  const [cmd, ...args] = command.split(' ')
+  const [cmd, ...args] = splitCommand(command)
   if (!cmd) return false
 
   const servers: Record<string, any> = config['amp.mcpServers'] ?? {}
@@ -98,16 +98,56 @@ export declare namespace register {
   }
 }
 
-/** @internal Detects the package specifier used to run this CLI (handles dlx/npx URL and version installs). */
-export function detectPackageSpecifier(name: string): string {
+/** @internal Builds the default MCP command for the current launch mode. */
+function defaultCommand(name: string, runner: string): string {
+  return shouldUseBareCommand(name)
+    ? `${name} --mcp`
+    : `${runner} ${detectPackageSpecifier(name)} --mcp`
+}
+
+/** @internal Returns node_modules path details for the current entrypoint. */
+function nodeModulesInfo(): { entry: string; root: string } | null {
+  const normalized = process.argv[1]?.replace(/\\/g, '/')
+  const match = normalized?.match(/^(.+)\/node_modules\/(.+)$/)
+  if (!match) return null
+  return { root: match[1]!, entry: match[2]! }
+}
+
+/** @internal Uses the bare command only when the binary is expected on PATH. */
+function shouldUseBareCommand(name: string): boolean {
   const bin = process.argv[1]
-  if (!bin) return name
+  if (!bin) return false
+
+  const info = nodeModulesInfo()
+  if (info) return !info.entry.startsWith('.bin/') && !packageDependsOn(info.root, name)
 
-  const match = bin.match(/^(.+)[/\\]node_modules[/\\]/)
-  if (!match) return name
+  const file = bin.replace(/\\/g, '/').split('/').pop()
+  return file === name || file === `${name}.cmd` || file === `${name}.ps1`
+}
 
+/** @internal Checks whether the entrypoint came from a project dependency install. */
+function packageDependsOn(root: string, name: string): boolean {
   try {
-    const pkg = JSON.parse(readFileSync(join(match[1]!, 'package.json'), 'utf-8'))
+    const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8'))
+    const dependencyFields = [
+      pkg.dependencies,
+      pkg.devDependencies,
+      pkg.optionalDependencies,
+      pkg.peerDependencies,
+    ]
+    return dependencyFields.some((dependencies) => name in (dependencies ?? {}))
+  } catch {
+    return false
+  }
+}
+
+/** @internal Detects the package specifier used to run this CLI (handles dlx/npx URL and version installs). */
+export function detectPackageSpecifier(name: string): string {
+  const info = nodeModulesInfo()
+  if (!info) return name
+
+  try {
+    const pkg = JSON.parse(readFileSync(join(info.root, 'package.json'), 'utf-8'))
     const deps = pkg.dependencies ?? {}
     const spec = deps[name]
     if (!spec || Object.keys(deps).length !== 1) return name
@@ -119,6 +159,30 @@ export function detectPackageSpecifier(name: string): string {
   return name
 }
 
+/** Splits a command string into tokens, respecting single and double quotes. */
+function splitCommand(input: string): string[] {
+  const tokens: string[] = []
+  let current = ''
+  let quote: string | null = null
+
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i]!
+    if (quote) {
+      if (ch === quote) quote = null
+      else current += ch
+    } else if (ch === '"' || ch === "'") {
+      quote = ch
+    } else if (ch === ' ') {
+      if (current) tokens.push(current)
+      current = ''
+    } else {
+      current += ch
+    }
+  }
+  if (current) tokens.push(current)
+  return tokens
+}
+
 /** Promisified execFile with stderr in error message. */
 function exec(cmd: string, args: string[]): Promise<{ stdout: string; stderr: string }> {
   return new Promise((resolve, reject) => {

package/src/SyncSkills.test.ts

@@ -1,4 +1,4 @@
-import { Cli, SyncSkills } from 'incur'
+import { Cli, SyncSkills, z } from 'incur'
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -161,6 +161,45 @@ test('installed SKILL.md contains frontmatter', async () => {
   rmSync(tmp, { recursive: true, force: true })
 })
 
+test('installed SKILL.md marks destructive commands', async () => {
+  const tmp = join(tmpdir(), `clac-destructive-test-${Date.now()}`)
+  mkdirSync(tmp, { recursive: true })
+
+  const cli = Cli.create('my-tool')
+  cli.command('destroy', {
+    description: 'Destroy data',
+    destructive: true,
+    hint: 'Deletes all data.',
+    run: () => ({}),
+  })
+  cli.command('status', {
+    description: 'Check status',
+    hint: 'Shows current status.',
+    run: () => ({}),
+  })
+
+  const commands = Cli.toCommands.get(cli)!
+  const installDir = join(tmp, 'install')
+  mkdirSync(join(installDir, '.agents', 'skills'), { recursive: true })
+
+  const result = await SyncSkills.sync('my-tool', commands, {
+    depth: 0,
+    global: false,
+    cwd: installDir,
+  })
+
+  const content = readFileSync(join(result.paths[0]!, 'SKILL.md'), 'utf8')
+  expect(content).toContain(
+    'Deletes all data. Confirm with the user before executing this destructive command.',
+  )
+  expect(content).toContain('Shows current status.')
+  expect(content).not.toContain(
+    'Shows current status. Confirm with the user before executing this destructive command.',
+  )
+
+  rmSync(tmp, { recursive: true, force: true })
+})
+
 test('sync returns unquoted descriptions from YAML frontmatter', async () => {
   const tmp = join(tmpdir(), `clac-quoted-description-test-${Date.now()}`)
   mkdirSync(tmp, { recursive: true })
@@ -288,6 +327,44 @@ test('list includes root command skill', async () => {
   expect(names).toContain('test-ping')
 })
 
+test('sync uses CLI skill projection for aliases, fetch gateways, examples, and output', async () => {
+  const tmp = join(tmpdir(), `clac-sync-drift-test-${Date.now()}`)
+  mkdirSync(tmp, { recursive: true })
+
+  const cli = Cli.create('tool')
+    .command('real', {
+      description: 'Real command',
+      aliases: ['r'],
+      options: z.object({ dryRun: z.boolean().default(false) }),
+      output: z.object({ value: z.string() }),
+      examples: [{ options: { dryRun: true }, description: 'Preview' }],
+      run: () => ({ value: 'ok' }),
+    })
+    .command('api', { description: 'Raw API', fetch: () => new Response('{}') })
+
+  const commands = Cli.toCommands.get(cli)!
+  const listed = await SyncSkills.list('tool', commands)
+  const names = listed.map((skill) => skill.name)
+  expect(names).toContain('tool-api')
+  expect(names).toContain('tool-real')
+  expect(names).not.toContain('tool-r')
+
+  const installDir = join(tmp, 'install')
+  mkdirSync(join(installDir, '.agents', 'skills'), { recursive: true })
+  const synced = await SyncSkills.sync('tool', commands, {
+    depth: 0,
+    global: false,
+    cwd: installDir,
+  })
+  const content = readFileSync(join(synced.paths[0]!, 'SKILL.md'), 'utf8')
+  expect(content).toContain('Preview')
+  expect(content).toContain('## Output')
+  expect(content).toContain('Fetch gateway. Pass path segments')
+  expect(content).not.toMatch(/^# tool r$/m)
+
+  rmSync(tmp, { recursive: true, force: true })
+})
+
 test('list results are sorted alphabetically', async () => {
   const cli = Cli.create('test')
   cli.command('zebra', { description: 'Z command', run: () => ({}) })

package/src/SyncSkills.ts

@@ -2,10 +2,11 @@ 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 { collectSkillCommands, parseSkillFrontmatter } from './Cli.js'
 import * as Agents from './internal/agents.js'
+import * as Yaml from './internal/yaml.js'
+import type * as Mcp from './Mcp.js'
 import * as Skill from './Skill.js'
 
 /** Generates skill files from a command map and installs them natively. */
@@ -17,9 +18,12 @@ export async function sync(
   const { depth = 1, description, global = true } = options
   const cwd = options.cwd ?? (global ? resolvePackageRoot() : process.cwd())
 
+  // Pre-load yaml for the sync call paths below (`Skill.split`, `parseFrontmatter`).
+  await Yaml.load()
+
   const groups = new Map<string, string>()
   if (description) groups.set(name, description)
-  const entries = collectEntries(commands, [], groups, options.rootCommand)
+  const entries = collectSkillCommands(commands, [], groups, options.rootCommand)
   const files = Skill.split(name, entries, depth, groups)
 
   const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), `incur-skills-${name}-`))
@@ -31,7 +35,7 @@ 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 meta = parseFrontmatter(file.content)
+      const meta = parseSkillFrontmatter(file.content)
       skills.push({ name: meta.name ?? (file.dir || name), description: meta.description })
     }
 
@@ -42,7 +46,7 @@ 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 meta = parseFrontmatter(content)
+            const meta = parseSkillFrontmatter(content)
             const skillName =
               pattern === '_root' ? (meta.name ?? name) : path.basename(path.dirname(match))
             const dest = path.join(tmpDir, skillName, 'SKILL.md')
@@ -68,7 +72,7 @@ export async function sync(
     }
 
     // Write skills hash + names for staleness detection
-    const hashEntries = collectEntries(commands, [], undefined, options.rootCommand)
+    const hashEntries = collectSkillCommands(commands, [], new Map(), options.rootCommand)
     writeMeta(
       name,
       Skill.hash(hashEntries),
@@ -100,8 +104,10 @@ export declare namespace sync {
       | {
           description?: string | undefined
           args?: any
+          destructive?: boolean | undefined
           env?: any
           hint?: string | undefined
+          mcp?: { annotations?: Mcp.ToolAnnotations | undefined } | undefined
           options?: any
           output?: any
           examples?: any[] | undefined
@@ -137,16 +143,19 @@ export async function list(
   const { depth = 1, description } = options
   const cwd = options.cwd ?? process.cwd()
 
+  // Pre-load yaml for the sync call paths below (`Skill.split`, `parseFrontmatter`).
+  await Yaml.load()
+
   const groups = new Map<string, string>()
   if (description) groups.set(name, description)
-  const entries = collectEntries(commands, [], groups, options.rootCommand)
+  const entries = collectSkillCommands(commands, [], groups, options.rootCommand)
   const files = Skill.split(name, entries, depth, groups)
 
   const skills: list.Skill[] = []
   const installed = readInstalledSkills(name, { cwd })
 
   for (const file of files) {
-    const meta = parseFrontmatter(file.content)
+    const meta = parseSkillFrontmatter(file.content)
     const skillName = meta.name ?? (file.dir || name)
     skills.push({
       name: skillName,
@@ -162,7 +171,7 @@ 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 meta = parseFrontmatter(content)
+          const meta = parseSkillFrontmatter(content)
           const skillName =
             pattern === '_root' ? (meta.name ?? name) : path.basename(path.dirname(match))
           if (!skills.some((s) => s.name === skillName)) {
@@ -204,8 +213,10 @@ export declare namespace list {
       | {
           description?: string | undefined
           args?: any
+          destructive?: boolean | undefined
           env?: any
           hint?: string | undefined
+          mcp?: { annotations?: Mcp.ToolAnnotations | undefined } | undefined
           options?: any
           output?: any
           examples?: any[] | undefined
@@ -223,75 +234,6 @@ export declare namespace list {
   }
 }
 
-/** Recursively collects leaf commands as `Skill.CommandInfo`. */
-function collectEntries(
-  commands: Map<string, any>,
-  prefix: string[],
-  groups: Map<string, string> = new Map(),
-  rootCommand?:
-    | {
-        description?: string | undefined
-        args?: any
-        env?: any
-        hint?: string | undefined
-        options?: any
-        output?: any
-        examples?: any[] | undefined
-      }
-    | undefined,
-): Skill.CommandInfo[] {
-  const result: Skill.CommandInfo[] = []
-  if (rootCommand) {
-    const cmd: Skill.CommandInfo = {}
-    if (rootCommand.description) cmd.description = rootCommand.description
-    if (rootCommand.args) cmd.args = rootCommand.args
-    if (rootCommand.env) cmd.env = rootCommand.env
-    if (rootCommand.hint) cmd.hint = rootCommand.hint
-    if (rootCommand.options) cmd.options = rootCommand.options
-    if (rootCommand.output) cmd.output = rootCommand.output
-    const examples = formatExamples(rootCommand.examples)
-    if (examples) cmd.examples = examples
-    result.push(cmd)
-  }
-  for (const [name, entry] of commands) {
-    const entryPath = [...prefix, name]
-    if ('_group' in entry && entry._group) {
-      if (entry.description) groups.set(entryPath.join(' '), entry.description)
-      result.push(...collectEntries(entry.commands, entryPath, groups))
-    } else {
-      const cmd: Skill.CommandInfo = { name: entryPath.join(' ') }
-      if (entry.description) cmd.description = entry.description
-      if (entry.args) cmd.args = entry.args
-      if (entry.env) cmd.env = entry.env
-      if (entry.hint) cmd.hint = entry.hint
-      if (entry.options) cmd.options = entry.options
-      if (entry.output) cmd.output = entry.output
-      const examples = formatExamples(entry.examples)
-      if (examples) {
-        const cmdName = entryPath.join(' ')
-        cmd.examples = examples.map((e) => ({
-          ...e,
-          command: e.command ? `${cmdName} ${e.command}` : cmdName,
-        }))
-      }
-      result.push(cmd)
-    }
-  }
-  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/bun-compile.test.ts

@@ -70,6 +70,11 @@ cli.serve()
     expect(stdout).toContain('result: HELLO')
   })
 
+  test('runs command with --format yaml (lazy yaml import)', async () => {
+    const { stdout } = await exec(bin, ['ping', '--format', 'yaml'])
+    expect(stdout).toContain('pong: true')
+  })
+
   test('shows help', async () => {
     const { stdout } = await exec(bin, ['--help'])
     expect(stdout).toContain('test-cli')