@uzukko/agentpm 0.1.0

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@uzukko/agentpm",
+  "version": "0.1.0",
+  "description": "CLI for TaskApp - AI-first task management",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "agentpm": "./bin/taskapp.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/src/api-client.ts

@@ -0,0 +1,32 @@
+let _apiUrl: string | undefined
+let _apiKey: string | undefined
+
+export function setApiConfig(apiUrl: string, apiKey: string): void {
+  _apiUrl = apiUrl
+  _apiKey = apiKey
+}
+
+export async function callTool(toolName: string, params: Record<string, unknown>): Promise<unknown> {
+  if (!_apiUrl || !_apiKey) {
+    console.error('Error: Not configured. Run: agentpm login')
+    process.exit(1)
+  }
+
+  const url = `${_apiUrl.replace(/\/$/, '')}/api/tools`
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${_apiKey}`,
+    },
+    body: JSON.stringify({ tool: toolName, params }),
+  })
+
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({ error: `HTTP ${response.status}` })) as { error?: string; details?: string }
+    throw new Error(body.error || body.details || `HTTP ${response.status}`)
+  }
+
+  return response.json()
+}

package/src/commands/activity.ts

@@ -0,0 +1,83 @@
+import { Command } from 'commander'
+import { resolveSpaceId } from '../config.js'
+import { callTool } from '../api-client.js'
+import { output, outputError } from '../output.js'
+
+export function registerActivityCommands(program: Command): void {
+  const activity = program.command('activity').description('Activity log')
+
+  activity
+    .command('search')
+    .description('Search activity logs')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .option('--entity-table <table>', 'Filter by table name')
+    .option('--entity-id <uuid>', 'Filter by entity ID')
+    .option('--actor-id <uuid>', 'Filter by actor ID')
+    .option('--action <action>', 'Filter by action')
+    .option('--from <datetime>', 'Start datetime (ISO8601)')
+    .option('--to <datetime>', 'End datetime (ISO8601)')
+    .option('--session-id <uuid>', 'Filter by session ID')
+    .option('--limit <n>', 'Max results', '100')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('activity_search', {
+          spaceId: resolveSpaceId(opts),
+          entityTable: opts.entityTable,
+          entityId: opts.entityId,
+          actorId: opts.actorId,
+          action: opts.action,
+          from: opts.from,
+          to: opts.to,
+          sessionId: opts.sessionId,
+          limit: parseInt(opts.limit),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  activity
+    .command('log')
+    .description('Create an activity log entry')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--entity-table <table>', 'Table name')
+    .requiredOption('--entity-id <uuid>', 'Entity ID')
+    .requiredOption('--action <action>', 'Action')
+    .option('--actor-type <type>', 'user|system|ai|service', 'ai')
+    .option('--actor-service <service>', 'Service name')
+    .option('--entity-display <name>', 'Display name')
+    .option('--reason <reason>', 'Reason')
+    .option('--status <status>', 'ok|error|warning', 'ok')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('activity_log', {
+          spaceId: resolveSpaceId(opts),
+          entityTable: opts.entityTable,
+          entityId: opts.entityId,
+          action: opts.action,
+          actorType: opts.actorType,
+          actorService: opts.actorService,
+          entityDisplay: opts.entityDisplay,
+          reason: opts.reason,
+          status: opts.status,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  activity
+    .command('history')
+    .description('Get entity change history')
+    .requiredOption('--entity-table <table>', 'Table name')
+    .requiredOption('--entity-id <uuid>', 'Entity ID')
+    .option('--limit <n>', 'Max results', '50')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('activity_entity_history', {
+          entityTable: opts.entityTable,
+          entityId: opts.entityId,
+          limit: parseInt(opts.limit),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+}

package/src/commands/ball.ts

@@ -0,0 +1,64 @@
+import { Command } from 'commander'
+import { resolveSpaceId } from '../config.js'
+import { callTool } from '../api-client.js'
+import { output, outputError } from '../output.js'
+
+export function registerBallCommands(program: Command): void {
+  const ball = program.command('ball').description('Ball (ownership) management')
+
+  ball
+    .command('pass')
+    .description('Pass ball ownership')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--task-id <uuid>', 'Task UUID')
+    .requiredOption('--ball <side>', 'New ball owner: client|internal')
+    .option('--client-owner-ids <ids...>', 'Client owner UUIDs')
+    .option('--internal-owner-ids <ids...>', 'Internal owner UUIDs')
+    .option('--reason <reason>', 'Reason for passing')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('ball_pass', {
+          spaceId: resolveSpaceId(opts),
+          taskId: opts.taskId,
+          ball: opts.ball,
+          clientOwnerIds: opts.clientOwnerIds || [],
+          internalOwnerIds: opts.internalOwnerIds || [],
+          reason: opts.reason,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  ball
+    .command('query')
+    .description('Query tasks by ball side')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--ball <side>', 'Ball side: client|internal')
+    .option('--include-owners', 'Include owner info')
+    .option('--limit <n>', 'Max results', '50')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('ball_query', {
+          spaceId: resolveSpaceId(opts),
+          ball: opts.ball,
+          includeOwners: opts.includeOwners || false,
+          limit: parseInt(opts.limit),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  // Dashboard as top-level shortcut
+  program
+    .command('dashboard')
+    .description('Get project dashboard')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('dashboard_get', {
+          spaceId: resolveSpaceId(opts),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+}

package/src/commands/client.ts

@@ -0,0 +1,135 @@
+import { Command } from 'commander'
+import { resolveSpaceId } from '../config.js'
+import { callTool } from '../api-client.js'
+import { output, outputError } from '../output.js'
+
+export function registerClientCommands(program: Command): void {
+  const client = program.command('client').description('Client management')
+
+  client
+    .command('list')
+    .description('List clients')
+    .option('-s, --space-id <uuid>', 'Filter by space UUID')
+    .option('--no-include-invites', 'Exclude pending invites')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('client_list', {
+          spaceId: opts.spaceId,
+          includeInvites: opts.includeInvites !== false,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  client
+    .command('get')
+    .description('Get client details')
+    .requiredOption('--user-id <uuid>', 'Client user UUID')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('client_get', { userId: opts.userId })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  client
+    .command('update')
+    .description('Update client role in a space')
+    .requiredOption('--user-id <uuid>', 'Client user UUID')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--role <role>', 'New role: client|viewer')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('client_update', {
+          userId: opts.userId,
+          spaceId: resolveSpaceId(opts),
+          role: opts.role,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  client
+    .command('add-to-space')
+    .description('Add client to a space')
+    .requiredOption('--user-id <uuid>', 'Client user UUID')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .option('--role <role>', 'Role: client|viewer', 'client')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('client_add_to_space', {
+          userId: opts.userId,
+          spaceId: resolveSpaceId(opts),
+          role: opts.role,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  // Invite subcommands
+  const invite = client.command('invite').description('Client invitations')
+
+  invite
+    .command('create')
+    .description('Create a client invite')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--email <email>', 'Client email')
+    .option('--expires-in-days <n>', 'Expiry days', '7')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('client_invite_create', {
+          email: opts.email,
+          spaceId: resolveSpaceId(opts),
+          expiresInDays: parseInt(opts.expiresInDays),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  invite
+    .command('bulk-create')
+    .description('Bulk create client invites')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--emails <emails...>', 'Client emails (max 50)')
+    .option('--expires-in-days <n>', 'Expiry days', '7')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('client_invite_bulk_create', {
+          emails: opts.emails,
+          spaceId: resolveSpaceId(opts),
+          expiresInDays: parseInt(opts.expiresInDays),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  invite
+    .command('list')
+    .description('List client invites')
+    .option('-s, --space-id <uuid>', 'Filter by space')
+    .option('--status <status>', 'pending|accepted|expired|all', 'pending')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('client_invite_list', {
+          spaceId: opts.spaceId,
+          status: opts.status,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  invite
+    .command('resend')
+    .description('Resend a client invite')
+    .requiredOption('--invite-id <uuid>', 'Invite UUID')
+    .option('--expires-in-days <n>', 'New expiry days', '7')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('client_invite_resend', {
+          inviteId: opts.inviteId,
+          expiresInDays: parseInt(opts.expiresInDays),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+}

package/src/commands/config-cmd.ts

@@ -0,0 +1,106 @@
+import { Command } from 'commander'
+import { writeFileSync, existsSync, readFileSync, unlinkSync } from 'node:fs'
+import { createInterface } from 'node:readline'
+import { getConfigPath } from '../config.js'
+
+async function prompt(question: string, defaultValue?: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stderr })
+  const suffix = defaultValue ? ` [${defaultValue}]` : ''
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close()
+      resolve(answer.trim() || defaultValue || '')
+    })
+  })
+}
+
+function loadExisting(): Record<string, string> {
+  const configPath = getConfigPath()
+  if (existsSync(configPath)) {
+    try {
+      return JSON.parse(readFileSync(configPath, 'utf-8'))
+    } catch { /* ignore */ }
+  }
+  return {}
+}
+
+function maskSecret(value: string | undefined): string | undefined {
+  if (!value) return undefined
+  return value.slice(0, 8) + '...' + value.slice(-4)
+}
+
+export function registerConfigCommand(program: Command): void {
+  // agentpm login
+  program
+    .command('login')
+    .description('Login with your API Key (get it from Web UI → Settings → API Keys)')
+    .action(async () => {
+      const configPath = getConfigPath()
+      const existing = loadExisting()
+
+      console.error('AgentPM CLI Login')
+      console.error('─'.repeat(40))
+
+      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
+      }
+
+      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}`)
+
+      if (config.apiKey || existing.apiKey) {
+        console.error('✓ Run `agentpm space list` to verify your setup')
+      }
+    })
+
+  // agentpm config — advanced config management
+  const cfg = program.command('config').description('CLI configuration')
+
+  cfg
+    .command('show')
+    .description('Show current config (secrets masked)')
+    .action(() => {
+      const configPath = getConfigPath()
+
+      if (!existsSync(configPath)) {
+        console.error(`No config file at ${configPath}`)
+        console.error('Run: agentpm login')
+        process.exit(1)
+      }
+
+      const content = JSON.parse(readFileSync(configPath, 'utf-8'))
+      const masked = { ...content }
+      if (masked.apiKey) masked.apiKey = maskSecret(masked.apiKey)
+      console.log(JSON.stringify(masked, null, 2))
+    })
+
+  cfg
+    .command('path')
+    .description('Print config file path')
+    .action(() => {
+      console.log(getConfigPath())
+    })
+
+  cfg
+    .command('reset')
+    .description('Delete config file')
+    .action(() => {
+      const configPath = getConfigPath()
+      if (existsSync(configPath)) {
+        unlinkSync(configPath)
+        console.error(`Deleted ${configPath}`)
+      } else {
+        console.error('No config file to delete')
+      }
+    })
+}

package/src/commands/meeting.ts

@@ -0,0 +1,91 @@
+import { Command } from 'commander'
+import { resolveSpaceId } from '../config.js'
+import { callTool } from '../api-client.js'
+import { output, outputError } from '../output.js'
+
+export function registerMeetingCommands(program: Command): void {
+  const meeting = program.command('meeting').description('Meeting management')
+
+  meeting
+    .command('list')
+    .description('List meetings')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .option('--status <status>', 'Filter: planned|in_progress|ended')
+    .option('--limit <n>', 'Max results', '20')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('meeting_list', {
+          spaceId: resolveSpaceId(opts),
+          status: opts.status,
+          limit: parseInt(opts.limit),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  meeting
+    .command('create')
+    .description('Create a meeting')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--title <title>', 'Meeting title')
+    .option('--held-at <datetime>', 'Date/time (ISO8601)')
+    .option('--notes <notes>', 'Pre-meeting notes')
+    .option('--participant-ids <ids...>', 'Participant UUIDs')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('meeting_create', {
+          spaceId: resolveSpaceId(opts),
+          title: opts.title,
+          heldAt: opts.heldAt,
+          notes: opts.notes,
+          participantIds: opts.participantIds || [],
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  meeting
+    .command('start')
+    .description('Start a meeting')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--meeting-id <uuid>', 'Meeting UUID')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('meeting_start', {
+          spaceId: resolveSpaceId(opts),
+          meetingId: opts.meetingId,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  meeting
+    .command('end')
+    .description('End a meeting')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--meeting-id <uuid>', 'Meeting UUID')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('meeting_end', {
+          spaceId: resolveSpaceId(opts),
+          meetingId: opts.meetingId,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  meeting
+    .command('get')
+    .description('Get meeting details')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--meeting-id <uuid>', 'Meeting UUID')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('meeting_get', {
+          spaceId: resolveSpaceId(opts),
+          meetingId: opts.meetingId,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+}

package/src/commands/milestone.ts

@@ -0,0 +1,89 @@
+import { Command } from 'commander'
+import { resolveSpaceId } from '../config.js'
+import { callTool } from '../api-client.js'
+import { output, outputError } from '../output.js'
+
+export function registerMilestoneCommands(program: Command): void {
+  const ms = program.command('milestone').description('Milestone management')
+
+  ms
+    .command('list')
+    .description('List milestones')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('milestone_list', {
+          spaceId: resolveSpaceId(opts),
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  ms
+    .command('create')
+    .description('Create a milestone')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--name <name>', 'Milestone name')
+    .option('--due-date <date>', 'Due date (YYYY-MM-DD)')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('milestone_create', {
+          spaceId: resolveSpaceId(opts),
+          name: opts.name,
+          dueDate: opts.dueDate,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  ms
+    .command('update')
+    .description('Update a milestone')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--milestone-id <uuid>', 'Milestone UUID')
+    .option('--name <name>', 'New name')
+    .option('--due-date <date>', 'New due date')
+    .option('--order-key <n>', 'Display order key')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('milestone_update', {
+          spaceId: resolveSpaceId(opts),
+          milestoneId: opts.milestoneId,
+          name: opts.name,
+          dueDate: opts.dueDate,
+          orderKey: opts.orderKey !== undefined ? parseInt(opts.orderKey) : undefined,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  ms
+    .command('get')
+    .description('Get milestone details')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--milestone-id <uuid>', 'Milestone UUID')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('milestone_get', {
+          spaceId: resolveSpaceId(opts),
+          milestoneId: opts.milestoneId,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+
+  ms
+    .command('delete')
+    .description('Delete a milestone')
+    .option('-s, --space-id <uuid>', 'Space UUID')
+    .requiredOption('--milestone-id <uuid>', 'Milestone UUID')
+    .action(async (opts) => {
+      try {
+        const result = await callTool('milestone_delete', {
+          spaceId: resolveSpaceId(opts),
+          milestoneId: opts.milestoneId,
+        })
+        output(result, program.opts().json)
+      } catch (e) { outputError(e, program.opts().json) }
+    })
+}