@uzukko/agentpm 0.1.0

package/src/config.ts

@@ -0,0 +1,56 @@
+import { readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { setApiConfig } from './api-client.js'
+
+const CONFIG_PATH = join(homedir(), '.taskapprc.json')
+
+interface CliConfig {
+  apiUrl?: string
+  apiKey?: string
+  defaultSpaceId?: string
+}
+
+export function getConfigPath(): string {
+  return CONFIG_PATH
+}
+
+export function loadCliConfig(cliOpts: {
+  apiKey?: string
+  spaceId?: string
+}): void {
+  let fileConfig: CliConfig = {}
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      fileConfig = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'))
+    } catch {
+      // ignore invalid config file
+    }
+  }
+
+  // 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 (!apiUrl || !apiKey) {
+    console.error('Error: Not configured. Run: agentpm login')
+    process.exit(1)
+  }
+
+  setApiConfig(apiUrl, apiKey)
+
+  // Set space ID for resolveSpaceId
+  const spaceId = cliOpts.spaceId || process.env.TASKAPP_SPACE_ID || fileConfig.defaultSpaceId
+  if (spaceId) {
+    process.env.TASKAPP_SPACE_ID = spaceId
+  }
+}
+
+export function resolveSpaceId(opts: { spaceId?: string }): string {
+  const spaceId = opts.spaceId || process.env.TASKAPP_SPACE_ID
+  if (!spaceId) {
+    console.error('Error: --space-id is required (or set TASKAPP_SPACE_ID / defaultSpaceId in ~/.taskapprc.json)')
+    process.exit(1)
+  }
+  return spaceId
+}

package/src/index.ts

@@ -0,0 +1,51 @@
+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 { registerConfigCommand } from './commands/config-cmd.js'
+
+const program = new Command()
+
+program
+  .name('agentpm')
+  .version('0.1.0')
+  .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)
+    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
+
+    const opts = thisCommand.opts()
+    loadCliConfig({ apiKey: opts.apiKey, spaceId: opts.spaceId })
+  })
+
+registerTaskCommands(program)
+registerBallCommands(program)
+registerMeetingCommands(program)
+registerReviewCommands(program)
+registerMilestoneCommands(program)
+registerSpaceCommands(program)
+registerActivityCommands(program)
+registerClientCommands(program)
+registerWikiCommands(program)
+registerMinutesCommands(program)
+registerSchedulingCommands(program)
+registerConfigCommand(program)
+
+program.parseAsync()

package/src/output.ts

@@ -0,0 +1,139 @@
+import chalk from 'chalk'
+import Table from 'cli-table3'
+
+export function output(data: unknown, jsonMode: boolean): void {
+  if (jsonMode) {
+    console.log(JSON.stringify(data, null, 2))
+  } else {
+    if (Array.isArray(data)) {
+      printTable(data)
+    } else if (data && typeof data === 'object') {
+      const obj = data as Record<string, unknown>
+      const entries = Object.entries(obj)
+
+      // Display all array-of-objects properties as tables
+      for (const [key, value] of entries) {
+        if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object' && value[0] !== null) {
+          console.log(chalk.bold(`${key}:`))
+          printTable(value as Record<string, unknown>[])
+          console.log()
+        }
+      }
+
+      // Print remaining non-array-of-objects values
+      for (const [key, value] of entries) {
+        if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object' && value[0] !== null) {
+          continue // already printed as table
+        }
+        if (value === null || value === undefined) continue
+        if (Array.isArray(value)) {
+          console.log(`${chalk.gray(key)}: ${value.map(v => String(v)).join(', ')}`)
+        } else if (typeof value === 'object') {
+          console.log(`${chalk.gray(key)}: ${JSON.stringify(value, null, 2)}`)
+        } else {
+          console.log(`${chalk.gray(key)}: ${formatValue(key, value)}`)
+        }
+      }
+    } else {
+      console.log(data)
+    }
+  }
+}
+
+function printTable(rows: unknown[]): void {
+  if (rows.length === 0) {
+    console.log(chalk.gray('(no results)'))
+    return
+  }
+
+  // Collect scalar keys from ALL rows (preserving insertion order from first occurrence)
+  const seen = new Set<string>()
+  const keys: string[] = []
+  for (const row of rows) {
+    const r = row as Record<string, unknown>
+    for (const k of Object.keys(r)) {
+      if (seen.has(k)) continue
+      seen.add(k)
+      // Include only scalar-ish columns (skip nested objects/arrays)
+      const v = r[k]
+      if (v === null || v === undefined || typeof v !== 'object' || v instanceof Date) {
+        keys.push(k)
+      }
+    }
+  }
+
+  // Limit columns for readability
+  const displayKeys = keys.slice(0, 8)
+
+  const table = new Table({
+    head: displayKeys.map((k) => chalk.cyan(k)),
+    style: { head: [], border: [] },
+    wordWrap: true,
+  })
+
+  for (const row of rows) {
+    const r = row as Record<string, unknown>
+    table.push(displayKeys.map((k) => {
+      const v = r[k]
+      return formatValue(k, v)
+    }))
+  }
+
+  console.log(table.toString())
+  console.log(chalk.gray(`${rows.length} row(s)`))
+}
+
+function formatValue(key: string, value: unknown): string {
+  if (value === null || value === undefined) return chalk.gray('-')
+  if (typeof value === 'string') {
+    // Status coloring
+    if (key === 'status' || key === 'ball') {
+      return colorStatus(value)
+    }
+    // Truncate long strings
+    if (value.length > 50) return value.slice(0, 47) + '...'
+    return value
+  }
+  if (typeof value === 'number') return chalk.yellow(String(value))
+  if (typeof value === 'boolean') return value ? chalk.green('true') : chalk.red('false')
+  return String(value)
+}
+
+function colorStatus(status: string): string {
+  switch (status) {
+    case 'done':
+    case 'approved':
+    case 'confirmed':
+    case 'accepted':
+      return chalk.green(status)
+    case 'in_progress':
+    case 'in_review':
+    case 'open':
+    case 'internal':
+      return chalk.blue(status)
+    case 'backlog':
+    case 'todo':
+    case 'planned':
+    case 'pending':
+      return chalk.yellow(status)
+    case 'considering':
+      return chalk.magenta(status)
+    case 'cancelled':
+    case 'expired':
+    case 'changes_requested':
+    case 'client':
+      return chalk.red(status)
+    default:
+      return status
+  }
+}
+
+export function outputError(error: unknown, jsonMode: boolean): void {
+  const message = error instanceof Error ? error.message : String(error)
+  if (jsonMode) {
+    console.error(JSON.stringify({ error: message }))
+  } else {
+    console.error(chalk.red(`Error: ${message}`))
+  }
+  process.exit(1)
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}