@uzukko/agentpm 0.1.2 → 0.2.0

package/src/builtin-manifest.ts

@@ -0,0 +1,121 @@
+/**
+ * Builtin manifest fallback.
+ * Used when: no cache, server unreachable, or CLI < minCliVersion.
+ * Contains a minimal subset of core commands for basic operation.
+ */
+import type { Manifest } from './manifest-validator.js'
+
+const spaceOpt = {
+  flags: '-s, --space-id <uuid>',
+  description: 'Space UUID',
+  param: 'spaceId',
+  resolve: 'spaceId' as const,
+}
+
+export const BUILTIN_MANIFEST: Manifest = {
+  version: '0.0.0-builtin',
+  minCliVersion: '0.0.0',
+  generatedAt: '1970-01-01T00:00:00Z',
+  checksum: '',
+  commands: [
+    {
+      name: 'task',
+      description: 'Task management',
+      subcommands: [
+        {
+          name: 'list',
+          description: 'List tasks',
+          tool: 'task_list',
+          options: [
+            spaceOpt,
+            { flags: '--ball <side>', description: 'Filter: client|internal', param: 'ball' },
+            { flags: '--status <status>', description: 'Filter by status', param: 'status' },
+            { flags: '--limit <n>', description: 'Max results', param: 'limit', type: 'int', default: '50' },
+          ],
+        },
+        {
+          name: 'get',
+          description: 'Get task details',
+          tool: 'task_get',
+          options: [
+            spaceOpt,
+            { flags: '--task-id <uuid>', description: 'Task UUID', param: 'taskId', required: true },
+          ],
+        },
+        {
+          name: 'create',
+          description: 'Create a task',
+          tool: 'task_create',
+          options: [
+            spaceOpt,
+            { flags: '--title <title>', description: 'Task title', param: 'title', required: true },
+            { flags: '--description <desc>', description: 'Description', param: 'description' },
+            { flags: '--type <type>', description: 'task|spec', param: 'type', default: 'task' },
+            { flags: '--ball <side>', description: 'client|internal', param: 'ball', default: 'internal' },
+          ],
+        },
+        {
+          name: 'update',
+          description: 'Update a task',
+          tool: 'task_update',
+          options: [
+            spaceOpt,
+            { flags: '--task-id <uuid>', description: 'Task UUID', param: 'taskId', required: true },
+            { flags: '--title <title>', description: 'New title', param: 'title' },
+            { flags: '--status <status>', description: 'New status', param: 'status' },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'ball',
+      description: 'Ball ownership management',
+      subcommands: [
+        {
+          name: 'pass',
+          description: 'Pass ball ownership',
+          tool: 'ball_pass',
+          options: [
+            spaceOpt,
+            { flags: '--task-id <uuid>', description: 'Task UUID', param: 'taskId', required: true },
+            { flags: '--ball <side>', description: 'New owner', param: 'ball', required: true },
+          ],
+        },
+        {
+          name: 'query',
+          description: 'Query tasks by ball side',
+          tool: 'ball_query',
+          options: [
+            spaceOpt,
+            { flags: '--ball <side>', description: 'Ball side', param: 'ball', required: true },
+            { flags: '--limit <n>', description: 'Max results', param: 'limit', type: 'int', default: '50' },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'dashboard',
+      description: 'Get project dashboard',
+      tool: 'dashboard_get',
+      options: [spaceOpt],
+    },
+    {
+      name: 'space',
+      description: 'Space management',
+      subcommands: [
+        {
+          name: 'list',
+          description: 'List spaces',
+          tool: 'space_list',
+          options: [],
+        },
+        {
+          name: 'get',
+          description: 'Get space details',
+          tool: 'space_get',
+          options: [spaceOpt],
+        },
+      ],
+    },
+  ],
+}

package/src/commands/config-cmd.ts

@@ -40,22 +40,27 @@ export function registerConfigCommand(program: Command): void {
 
       console.error('AgentPM CLI Login')
       console.error('─'.repeat(40))
-      console.error('Get your API Key from: Settings → APIキー管理\n')
 
       const config: Record<string, string> = { ...existing }
 
+      const apiUrl = await prompt('API URL', existing.apiUrl || undefined)
+      if (apiUrl) config.apiUrl = apiUrl
+
+      console.error('\nPaste your API Key from Web UI → Settings → API Keys:')
       const apiKey = await prompt('API Key', existing.apiKey ? maskSecret(existing.apiKey) : undefined)
       if (apiKey && !apiKey.includes('...')) {
         config.apiKey = apiKey
       }
 
-      if (!config.apiUrl) {
-        config.apiUrl = 'https://agentpm.app'
-      }
+      const defaultSpaceId = await prompt('Default Space ID (optional, press Enter to skip)', existing.defaultSpaceId)
+      if (defaultSpaceId) config.defaultSpaceId = defaultSpaceId
 
       writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
       console.error(`\n✓ Config saved to ${configPath}`)
-      console.error('✓ Run `agentpm space list` to verify your setup')
+
+      if (config.apiKey || existing.apiKey) {
+        console.error('✓ Run `agentpm space list` to verify your setup')
+      }
     })
 
   // agentpm config — advanced config management

package/src/config.ts

@@ -11,6 +11,17 @@ interface CliConfig {
   defaultSpaceId?: string
 }
 
+export class ConfigError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'ConfigError'
+  }
+}
+
+// Store resolved config for getApiConfig()
+let _resolvedApiUrl = ''
+let _resolvedApiKey = ''
+
 export function getConfigPath(): string {
   return CONFIG_PATH
 }
@@ -28,15 +39,16 @@ export function loadCliConfig(cliOpts: {
     }
   }
 
-  // Priority: CLI flags > env vars > config file > default
-  const apiUrl = process.env.TASKAPP_API_URL || fileConfig.apiUrl || 'https://agentpm.app'
+  // Priority: CLI flags > env vars > config file
+  const apiUrl = process.env.TASKAPP_API_URL || fileConfig.apiUrl
   const apiKey = cliOpts.apiKey || process.env.TASKAPP_API_KEY || fileConfig.apiKey
 
-  if (!apiKey) {
-    console.error('Error: Not configured. Run: agentpm login')
-    process.exit(1)
+  if (!apiUrl || !apiKey) {
+    throw new ConfigError('Not configured. Run: agentpm login')
   }
 
+  _resolvedApiUrl = apiUrl
+  _resolvedApiKey = apiKey
   setApiConfig(apiUrl, apiKey)
 
   // Set space ID for resolveSpaceId
@@ -46,6 +58,10 @@ export function loadCliConfig(cliOpts: {
   }
 }
 
+export function getApiConfig(): { apiUrl: string; apiKey: string } {
+  return { apiUrl: _resolvedApiUrl, apiKey: _resolvedApiKey }
+}
+
 export function resolveSpaceId(opts: { spaceId?: string }): string {
   const spaceId = opts.spaceId || process.env.TASKAPP_SPACE_ID
   if (!spaceId) {

package/src/dynamic-loader.ts

@@ -0,0 +1,326 @@
+/**
+ * Dynamic command registration from manifest JSON.
+ * Converts manifest definitions → Commander.js commands at runtime.
+ */
+import { Command, Option } from 'commander'
+import { resolveSpaceId } from './config.js'
+import { callTool } from './api-client.js'
+import { output, outputError } from './output.js'
+import { sanitize } from './manifest-validator.js'
+import type {
+  Manifest,
+  ManifestCommand,
+  ManifestSubcommand,
+  ManifestOption,
+} from './manifest-validator.js'
+import chalk from 'chalk'
+
+/**
+ * Extract the long flag name from a flags string.
+ * e.g., "-s, --space-id <uuid>" → "space-id"
+ *       "--task-id <uuid>" → "task-id"
+ *       "--no-dry-run" → "no-dry-run"
+ */
+function extractLongFlag(flags: string): string {
+  const match = flags.match(/--([a-z][a-z0-9-]*)/)
+  return match ? match[1] : ''
+}
+
+/**
+ * Convert kebab-case to camelCase (Commander.js convention).
+ * e.g., "space-id" → "spaceId", "no-dry-run" → "noDryRun"
+ */
+function camelCase(str: string): string {
+  return str.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase())
+}
+
+/**
+ * Convert option value based on type definition.
+ */
+function convertType(value: string | boolean, type?: string): unknown {
+  if (type === 'bool' || type === 'negatable') {
+    return typeof value === 'boolean' ? value : value === 'true'
+  }
+  if (typeof value !== 'string') return value
+  switch (type) {
+    case 'int': {
+      const n = parseInt(value, 10)
+      if (Number.isNaN(n)) throw new Error(`Invalid integer: ${value}`)
+      return n
+    }
+    case 'float': {
+      const n = parseFloat(value)
+      if (Number.isNaN(n)) throw new Error(`Invalid number: ${value}`)
+      return n
+    }
+    case 'json':
+      return JSON.parse(value)
+    default:
+      return value
+  }
+}
+
+/**
+ * Build API params from Commander options + manifest option definitions.
+ */
+function buildParams(
+  optionDefs: ManifestOption[],
+  opts: Record<string, unknown>,
+): Record<string, unknown> {
+  const params: Record<string, unknown> = {}
+
+  for (const def of optionDefs) {
+    // Determine the Commander key for this option
+    const longFlag = extractLongFlag(def.flags)
+    const key = camelCase(longFlag)
+
+    // For negatable options (--no-xxx), Commander stores as the positive key
+    // e.g., --no-dry-run → opts.dryRun = false, --no-include-invites → opts.includeInvites = false
+    let value = opts[key]
+
+    // Skip stdin pseudo-option (handled separately)
+    if (def.param === 'stdin') continue
+
+    if (value === undefined) continue
+
+    // Special resolver: spaceId
+    if (def.resolve === 'spaceId') {
+      params[def.param] = resolveSpaceId(opts as { spaceId?: string })
+      continue
+    }
+
+    // Type conversion
+    if (def.type === 'string[]') {
+      // Commander already provides arrays for variadic options
+      params[def.param] = Array.isArray(value) ? value : [value]
+    } else if (def.type === 'negatable') {
+      // Commander stores boolean for --no-xxx
+      params[def.param] = value
+    } else {
+      params[def.param] = convertType(value as string, def.type)
+    }
+  }
+
+  return params
+}
+
+/**
+ * Resolve a constraint key to a Commander opts key.
+ * Handles negatable flags: "no-dry-run" → Commander stores as "dryRun" (boolean false).
+ */
+function resolveConstraintKey(
+  flagRef: string,
+  optionDefs: ManifestOption[],
+): { key: string; isNegatable: boolean } {
+  // Check if flagRef references a negatable option (--no-xxx)
+  if (flagRef.startsWith('no-')) {
+    const positiveFlag = flagRef.slice(3) // "no-dry-run" → "dry-run"
+    const positiveKey = camelCase(positiveFlag) // "dry-run" → "dryRun"
+    // Check if the option is actually negatable
+    const matchingOpt = optionDefs.find(
+      (o) => o.type === 'negatable' && extractLongFlag(o.flags) === `no-${positiveFlag}`,
+    )
+    if (matchingOpt) {
+      return { key: positiveKey, isNegatable: true }
+    }
+  }
+  return { key: camelCase(flagRef), isNegatable: false }
+}
+
+/**
+ * Validate dependsOn / conflictsWith constraints.
+ * Returns error message or null if valid.
+ */
+function validateConstraints(
+  optionDefs: ManifestOption[],
+  opts: Record<string, unknown>,
+): string | null {
+  for (const def of optionDefs) {
+    const selfKey = camelCase(extractLongFlag(def.flags))
+    if (opts[selfKey] === undefined) continue
+
+    // dependsOn: requires another option
+    if (def.dependsOn) {
+      const { key: depKey, isNegatable } = resolveConstraintKey(def.dependsOn, optionDefs)
+      // For negatable: "dryRun" will be false when --no-dry-run is passed
+      const depPresent = isNegatable
+        ? opts[depKey] === false // --no-xxx explicitly passed
+        : opts[depKey] !== undefined
+      if (!depPresent) {
+        return `--${extractLongFlag(def.flags)} requires --${def.dependsOn}`
+      }
+    }
+
+    // conflictsWith: mutually exclusive
+    if (def.conflictsWith) {
+      const { key: conflictKey, isNegatable } = resolveConstraintKey(def.conflictsWith, optionDefs)
+      const conflictPresent = isNegatable
+        ? opts[conflictKey] === false
+        : opts[conflictKey] !== undefined
+      if (conflictPresent) {
+        return `--${extractLongFlag(def.flags)} conflicts with --${def.conflictsWith}`
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Read stdin as JSON (for scheduling create/respond).
+ */
+async function readStdin(): Promise<Record<string, unknown>> {
+  const chunks: Buffer[] = []
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk as Buffer)
+  }
+  return JSON.parse(Buffer.concat(chunks).toString('utf-8'))
+}
+
+/**
+ * Create an action handler for a subcommand.
+ */
+function createAction(
+  sub: ManifestSubcommand,
+  program: Command,
+): (opts: Record<string, unknown>) => Promise<void> {
+  return async (opts: Record<string, unknown>) => {
+    const jsonMode = program.opts().json
+
+    // Deprecation warning
+    if (sub.deprecated) {
+      console.error(chalk.yellow(`Warning: "${sub.name}" is deprecated`))
+    }
+
+    // Constraint validation
+    const error = validateConstraints(sub.options, opts)
+    if (error) {
+      outputError(new Error(error), jsonMode)
+      return
+    }
+
+    try {
+      // stdin mode (scheduling create/respond)
+      if (sub.stdinMode && opts.stdin) {
+        const stdinParams = await readStdin()
+        // Merge CLI options into stdin params (CLI takes precedence for spaceId)
+        const spaceOpt = sub.options.find((o) => o.resolve === 'spaceId')
+        if (spaceOpt && !stdinParams.spaceId) {
+          try {
+            stdinParams.spaceId = resolveSpaceId(opts as { spaceId?: string })
+          } catch {
+            // spaceId not required for all commands
+          }
+        }
+        // Merge other required CLI options
+        for (const def of sub.options) {
+          if (def.param === 'stdin') continue
+          const key = camelCase(extractLongFlag(def.flags))
+          if (opts[key] !== undefined && stdinParams[def.param] === undefined) {
+            stdinParams[def.param] = opts[key]
+          }
+        }
+        const result = await callTool(sub.tool, stdinParams)
+        output(result, jsonMode)
+        return
+      }
+
+      // stdin required but not provided
+      if (sub.stdinMode && !opts.stdin) {
+        console.error(`Error: ${sub.name} requires --stdin with JSON input.`)
+        console.error(`Example: echo '{"key":"value"}' | agentpm ... --stdin`)
+        process.exit(1)
+      }
+
+      // Normal mode
+      const params = buildParams(sub.options, opts)
+      const result = await callTool(sub.tool, params)
+      output(result, jsonMode)
+    } catch (e) {
+      outputError(e, jsonMode)
+    }
+  }
+}
+
+/**
+ * Register a single option on a Commander command.
+ */
+function registerOption(cmd: Command, opt: ManifestOption): void {
+  const desc = sanitize(opt.description || '')
+  const option = new Option(opt.flags, desc)
+  if (opt.required) option.makeOptionMandatory(true)
+  if (opt.default !== undefined) option.default(opt.default)
+  if (opt.choices) option.choices(opt.choices)
+  cmd.addOption(option)
+}
+
+/**
+ * Register a subcommand on a parent command group.
+ */
+function registerSubcommand(
+  parent: Command,
+  sub: ManifestSubcommand,
+  program: Command,
+): void {
+  const subCmd = parent.command(sub.name).description(sanitize(sub.description))
+
+  if (sub.aliases) {
+    for (const alias of sub.aliases) subCmd.alias(alias)
+  }
+  if (sub.hidden) (subCmd as Command & { hideHelp: (h?: boolean) => Command }).hideHelp()
+  if (sub.examples?.length) {
+    subCmd.addHelpText(
+      'after',
+      '\nExamples:\n' + sub.examples.map((e) => `  $ ${sanitize(e)}`).join('\n'),
+    )
+  }
+
+  for (const opt of sub.options) {
+    registerOption(subCmd, opt)
+  }
+
+  subCmd.action(createAction(sub, program))
+}
+
+/**
+ * Register all commands from a manifest onto the program.
+ */
+export function registerDynamicCommands(
+  program: Command,
+  manifest: Manifest,
+): void {
+  for (const cmd of manifest.commands) {
+    // Top-level command with direct tool (e.g., dashboard)
+    if (cmd.tool && !cmd.subcommands) {
+      const topCmd = program.command(cmd.name).description(sanitize(cmd.description))
+      if (cmd.aliases) {
+        for (const alias of cmd.aliases) topCmd.alias(alias)
+      }
+      if (cmd.options) {
+        for (const opt of cmd.options) {
+          registerOption(topCmd, opt)
+        }
+      }
+      // Create a pseudo-subcommand definition for the action handler
+      const pseudoSub: ManifestSubcommand = {
+        name: cmd.name,
+        description: cmd.description,
+        tool: cmd.tool,
+        options: cmd.options || [],
+      }
+      topCmd.action(createAction(pseudoSub, program))
+      continue
+    }
+
+    // Command group with subcommands
+    if (cmd.subcommands) {
+      const group = program.command(cmd.name).description(sanitize(cmd.description))
+      if (cmd.aliases) {
+        for (const alias of cmd.aliases) group.alias(alias)
+      }
+      for (const sub of cmd.subcommands) {
+        registerSubcommand(group, sub, program)
+      }
+    }
+  }
+}

package/src/index.ts

@@ -1,51 +1,98 @@
 import { Command } from 'commander'
-import { loadCliConfig } from './config.js'
-import { registerTaskCommands } from './commands/task.js'
-import { registerBallCommands } from './commands/ball.js'
-import { registerMeetingCommands } from './commands/meeting.js'
-import { registerReviewCommands } from './commands/review.js'
-import { registerMilestoneCommands } from './commands/milestone.js'
-import { registerSpaceCommands } from './commands/space.js'
-import { registerActivityCommands } from './commands/activity.js'
-import { registerClientCommands } from './commands/client.js'
-import { registerWikiCommands } from './commands/wiki.js'
-import { registerMinutesCommands } from './commands/minutes.js'
-import { registerSchedulingCommands } from './commands/scheduling.js'
+import { loadCliConfig, getApiConfig, ConfigError } from './config.js'
 import { registerConfigCommand } from './commands/config-cmd.js'
+import { registerDynamicCommands } from './dynamic-loader.js'
+import { loadManifest, forceUpdate } from './manifest-cache.js'
+import chalk from 'chalk'
+
+const CLI_VERSION = '0.2.0'
 
 const program = new Command()
 
 program
   .name('agentpm')
-  .version('0.1.0')
+  .version(CLI_VERSION)
   .description('AgentPM CLI - AI-first task management')
   .option('--json', 'Output raw JSON')
   .option('-s, --space-id <uuid>', 'Override default space ID')
   .option('--api-key <key>', 'Override API key')
   .hook('preAction', (thisCommand, actionCommand) => {
-    // Walk up to find the root command name (handles nested subcommands)
+    // Walk up to find the root command name
     let cmd = actionCommand
     while (cmd.parent && cmd.parent !== thisCommand) {
       cmd = cmd.parent
     }
-    // config/login subcommands don't need auth
-    if (cmd.name() === 'config' || cmd.name() === 'login') return
+    // config/login/update don't need auth
+    const name = cmd.name()
+    if (name === 'config' || name === 'login' || name === 'update') return
 
     const opts = thisCommand.opts()
-    loadCliConfig({ apiKey: opts.apiKey, spaceId: opts.spaceId })
+    try {
+      loadCliConfig({ apiKey: opts.apiKey, spaceId: opts.spaceId })
+    } catch (e) {
+      if (e instanceof ConfigError) {
+        console.error(chalk.red(`Error: ${e.message}`))
+        process.exit(1)
+      }
+      throw e
+    }
   })
 
-registerTaskCommands(program)
-registerBallCommands(program)
-registerMeetingCommands(program)
-registerReviewCommands(program)
-registerMilestoneCommands(program)
-registerSpaceCommands(program)
-registerActivityCommands(program)
-registerClientCommands(program)
-registerWikiCommands(program)
-registerMinutesCommands(program)
-registerSchedulingCommands(program)
+// ── Always-builtin commands (needed before auth) ──
 registerConfigCommand(program)
 
-program.parseAsync()
+// ── Update command (force-fetch manifest) ──
+program
+  .command('update')
+  .description('Fetch latest command manifest from server')
+  .action(async () => {
+    const opts = program.opts()
+    loadCliConfig({ apiKey: opts.apiKey, spaceId: opts.spaceId })
+    const { apiUrl, apiKey } = getApiConfig()
+    try {
+      const manifest = await forceUpdate(apiUrl, apiKey)
+      console.log(chalk.green(`Updated to manifest v${manifest.version}`))
+      console.log(chalk.gray(`${manifest.commands.length} command groups, ` +
+        `${manifest.commands.reduce((n, c) => n + (c.subcommands?.length || 1), 0)} commands`))
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      console.error(chalk.red(`Update failed: ${msg}`))
+      process.exit(1)
+    }
+  })
+
+// ── Dynamic command registration ──
+async function main() {
+  // Try to load config for manifest fetch (non-fatal if not configured)
+  let apiUrl = ''
+  let apiKey: string | undefined
+  try {
+    const opts = program.opts()
+    // Parse known options without executing actions
+    const rawArgs = process.argv.slice(2)
+    const apiKeyIdx = rawArgs.indexOf('--api-key')
+    const passedApiKey = apiKeyIdx >= 0 ? rawArgs[apiKeyIdx + 1] : undefined
+    loadCliConfig({ apiKey: passedApiKey, spaceId: opts.spaceId })
+    const config = getApiConfig()
+    apiUrl = config.apiUrl
+    apiKey = config.apiKey
+  } catch {
+    // Not configured — will use builtin manifest
+  }
+
+  if (apiUrl) {
+    const manifest = await loadManifest(apiUrl, apiKey, CLI_VERSION)
+    registerDynamicCommands(program, manifest)
+  } else {
+    // No config — register builtin for --help to work
+    const { BUILTIN_MANIFEST } = await import('./builtin-manifest.js')
+    registerDynamicCommands(program, BUILTIN_MANIFEST)
+  }
+
+  await program.parseAsync()
+}
+
+main().catch((e) => {
+  console.error(chalk.red(e instanceof Error ? e.message : String(e)))
+  process.exit(1)
+})