@yokio42/unit-labs-cli 0.1.0 → 0.1.2

package/src/index.js

@@ -3,78 +3,183 @@ const { stdin: input, stdout: output } = require("process")
 const { CONFIG_FILE, DEFAULT_API_BASE, normalizeApiBase, readConfig, writeConfig } = require("./config")
 
 const UNIT_LABS_BANNER = String.raw`
- _   _ _   _ ___ _____     _        _    ____  ____  
-| | | | \ | |_ _|_   _|   | |      / \  | __ )/ ___| 
-| | | |  \| || |  | |     | |     / _ \ |  _ \\___ \ 
-| |_| | |\  || |  | |     | |___ / ___ \| |_) |___) |
- \___/|_| \_|___| |_|     |_____/_/   \_\____/|____/ 
+ /$$   /$$ /$$   /$$ /$$$$$$ /$$$$$$$$      /$$        /$$$$$$  /$$$$$$$   /$$$$$$ 
+| $$  | $$| $$$ | $$|_  $$_/|__  $$__/     | $$       /$$__  $$| $$__  $$ /$$__  $$
+| $$  | $$| $$$$| $$  | $$     | $$        | $$      | $$  \ $$| $$  \ $$| $$  \__/
+| $$  | $$| $$ $$ $$  | $$     | $$ /$$$$$$| $$      | $$$$$$$$| $$$$$$$ |  $$$$$$ 
+| $$  | $$| $$  $$$$  | $$     | $$|______/| $$      | $$__  $$| $$__  $$ \____  $$
+| $$  | $$| $$\  $$$  | $$     | $$        | $$      | $$  | $$| $$  \ $$ /$$  \ $$
+|  $$$$$$/| $$ \  $$ /$$$$$$   | $$        | $$$$$$$$| $$  | $$| $$$$$$$/|  $$$$$$/
+ \______/ |__/  \__/|______/   |__/        |________/|__/  |__/|_______/  \______/ 
 `
 
-const HELP_TEXT = `
+const ROOT_HELP = `
 Unit Labs CLI
 
+Usage:
+  unit-labs auth <command>
+  unit-labs config <command>
+  unit-labs project <command>
+  unit-labs stage <command>
+  unit-labs task <command>
+  unit-labs --help
+
+Quick start:
+  unit-labs auth login
+  unit-labs project ls
+  unit-labs project use 1
+  unit-labs task ls
+  unit-labs task new "Ship MVP"
+`
+
+const AUTH_HELP = `
 Usage:
   unit-labs auth login [--login <email>] [--password <password>] [--api <url>]
-  unit-labs auth logout
   unit-labs auth whoami
+  unit-labs auth logout
+`
+
+const CONFIG_HELP = `
+Usage:
   unit-labs config show
   unit-labs config set-api <url>
-  unit-labs --help
+`
 
-Options:
-  -l, --login       Login (email) for login
-  -e, --email       Alias for --login
-  -p, --password    Password for login
-  --api             API base URL (default: ${DEFAULT_API_BASE})
-  -h, --help        Show help
+const PROJECT_HELP = `
+Usage:
+  unit-labs project ls [--team <teamId>] [--json]
+  unit-labs project new --name "<name>" [--workflow stages|flat] [--team <teamId>]
+  unit-labs project view <number|name|id> [--json]
+  unit-labs project use <number|name|id>
+  unit-labs project current [--json]
 `
 
-function parseFlags(argv) {
+const STAGE_HELP = `
+Usage:
+  unit-labs stage ls [--project <number|name|id>] [--json]
+  unit-labs stage new --name "<name>" --description "<text>" [--project <number|name|id>]
+  unit-labs stage use <number|name|id> [--project <number|name|id>]
+  unit-labs stage current [--json]
+`
+
+const TASK_HELP = `
+Usage:
+  unit-labs task ls [--project <number|name|id>] [--stage <number|name|id>] [--all] [--json]
+  unit-labs task new "<title>" [--project <number|name|id>] [--stage <number|name|id>]
+  unit-labs task done <number|title|id> [--project <number|name|id>] [--stage <number|name|id>]
+  unit-labs task close <number|title|id> [--project <number|name|id>] [--stage <number|name|id>]
+  unit-labs task assign <number|title|id> <me|none|number|username|email|id> [--project ...] [--stage ...]
+  unit-labs task unassign <number|title|id> [--project ...] [--stage ...]
+  unit-labs task edit <number|title|id> --title "<new title>" [--project ...] [--stage ...]
+  unit-labs task rm <number|title|id> [--project ...] [--stage ...]
+  unit-labs task delete <number|title|id> [--project ...] [--stage ...]
+`
+
+const ASSIGNEE_SELF_REFS = new Set(["me", "self", "@me"])
+const ASSIGNEE_CLEAR_REFS = new Set(["none", "null", "-", "unassign", "clear"])
+
+function parseArgs(argv, shortAliases = {}) {
   const flags = {}
+  const positionals = []
 
   for (let i = 0; i < argv.length; i += 1) {
-    const key = argv[i]
-    const value = argv[i + 1]
+    const arg = argv[i]
 
-    if (key === "-l" || key === "--login") {
-      flags.login = value
-      i += 1
-      continue
-    }
-    if (key === "-e" || key === "--email") {
-      flags.login = value
-      i += 1
-      continue
+    if (arg === "--") {
+      positionals.push(...argv.slice(i + 1))
+      break
     }
-    if (key === "-p" || key === "--password") {
-      flags.password = value
-      i += 1
+
+    if (arg.startsWith("--")) {
+      const [rawKey, inlineValue] = arg.slice(2).split("=")
+      if (inlineValue !== undefined) {
+        flags[rawKey] = inlineValue
+        continue
+      }
+
+      const next = argv[i + 1]
+      if (next && !next.startsWith("-")) {
+        flags[rawKey] = next
+        i += 1
+      } else {
+        flags[rawKey] = true
+      }
       continue
     }
-    if (key === "--api") {
-      flags.apiBase = value
-      i += 1
+
+    if (arg.startsWith("-") && arg.length > 1) {
+      const short = arg.slice(1)
+      const key = shortAliases[short] || short
+      const next = argv[i + 1]
+      if (next && !next.startsWith("-")) {
+        flags[key] = next
+        i += 1
+      } else {
+        flags[key] = true
+      }
       continue
     }
+
+    positionals.push(arg)
   }
 
-  return flags
+  return { flags, positionals }
 }
 
-async function promptMissingCredentials({ login, password }) {
-  if (login && password) {
-    return { login, password }
+function shortId(id) {
+  if (!id) return "-"
+  const value = String(id)
+  if (value.length <= 8) return value
+  return `${value.slice(0, 4)}…${value.slice(-4)}`
+}
+
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2))
+}
+
+function printProjects(projects, currentProjectId) {
+  if (!Array.isArray(projects) || projects.length === 0) {
+    console.log("No projects")
+    return
   }
 
-  const rl = readline.createInterface({ input, output })
-  const nextLogin = login || (await rl.question("Login: ")).trim()
-  const nextPassword = password || (await rl.question("Password: ")).trim()
-  rl.close()
+  projects.forEach((project, index) => {
+    const marker = String(project._id) === String(currentProjectId) ? "*" : " "
+    const workflow = project.workflow_type || "stages"
+    console.log(
+      `${String(index + 1).padStart(2)}.${marker} ${project.project_name}  [${workflow}]  ${shortId(project._id)}`
+    )
+  })
+}
 
-  return {
-    login: nextLogin,
-    password: nextPassword,
+function printStages(stages, currentStageId) {
+  if (!Array.isArray(stages) || stages.length === 0) {
+    console.log("No stages")
+    return
+  }
+
+  stages.forEach((stage, index) => {
+    const marker = String(stage._id) === String(currentStageId) ? "*" : " "
+    const status = stage.status || "-"
+    console.log(
+      `${String(index + 1).padStart(2)}.${marker} ${stage.stage_name}  [${status}]  ${shortId(stage._id)}`
+    )
+  })
+}
+
+function printTasks(tasks, withStage = false) {
+  if (!Array.isArray(tasks) || tasks.length === 0) {
+    console.log("No tasks")
+    return
   }
+
+  tasks.forEach((task, index) => {
+    const done = task.is_done ? "x" : " "
+    const stagePrefix = withStage && task._stageName ? `(${task._stageName}) ` : ""
+    console.log(
+      `${String(index + 1).padStart(2)}. [${done}] ${stagePrefix}${task.title}  ${shortId(task._id)}`
+    )
+  })
 }
 
 function printWelcomeBanner() {
@@ -82,180 +187,958 @@ function printWelcomeBanner() {
   console.log(UNIT_LABS_BANNER)
 }
 
-async function request({ method, url, token, body }) {
-  const headers = {}
+function getErrorMessage(payload) {
+  if (typeof payload === "string") return payload
+  if (payload && typeof payload === "object" && payload.message) return payload.message
+  try {
+    return JSON.stringify(payload)
+  } catch (error) {
+    return "unknown error"
+  }
+}
 
-  if (token) {
-    headers.Authorization = `Bearer ${token}`
+function resolveMemberByRef(members, ref) {
+  if (!ref) {
+    throw new Error("assignee reference is required")
+  }
+
+  if (!Array.isArray(members) || members.length === 0) {
+    throw new Error("this team has no members to assign")
+  }
+
+  const raw = String(ref).trim()
+  if (!raw) {
+    throw new Error("assignee reference is required")
+  }
+
+  if (/^\d+$/.test(raw)) {
+    const index = Number(raw) - 1
+    if (index < 0 || index >= members.length) {
+      throw new Error(`assignee index out of range: ${raw}`)
+    }
+    return members[index]
+  }
+
+  const exactId = members.find(member => String(member.id || member._id) === raw)
+  if (exactId) {
+    return exactId
+  }
+
+  const lower = raw.toLowerCase()
+  const exactEmail = members.filter(member => String(member.email || "").toLowerCase() === lower)
+  if (exactEmail.length === 1) {
+    return exactEmail[0]
+  }
+  if (exactEmail.length > 1) {
+    throw new Error(`ambiguous assignee email "${raw}"`)
+  }
+
+  const exactUsername = members.filter(member => String(member.username || "").toLowerCase() === lower)
+  if (exactUsername.length === 1) {
+    return exactUsername[0]
+  }
+  if (exactUsername.length > 1) {
+    throw new Error(`ambiguous assignee username "${raw}"`)
+  }
+
+  const partial = members.filter(member => {
+    const username = String(member.username || "").toLowerCase()
+    const email = String(member.email || "").toLowerCase()
+    return username.includes(lower) || email.includes(lower)
+  })
+  if (partial.length === 1) {
+    return partial[0]
+  }
+  if (partial.length > 1) {
+    throw new Error(`ambiguous assignee reference "${raw}"`)
   }
 
+  throw new Error(`assignee not found: ${raw}`)
+}
+
+async function request({ apiBase, token, method, path, body, requiresAuth = true }) {
+  if (requiresAuth && !token) {
+    throw new Error("not logged in. run: unit-labs auth login")
+  }
+
+  const headers = {}
+  headers["X-Client-Source"] = "cli"
+  headers["User-Agent"] = "unit-labs-cli/0.1.0"
+  if (requiresAuth && token) {
+    headers.Authorization = `Bearer ${token}`
+  }
   if (body) {
     headers["Content-Type"] = "application/json"
   }
 
-  const response = await fetch(url, {
+  const response = await fetch(`${apiBase}${path}`, {
     method,
     headers,
     body: body ? JSON.stringify(body) : undefined,
   })
 
-  const text = await response.text()
-  let payload = text
+  const rawText = await response.text()
+  let payload = rawText
 
   try {
-    payload = text ? JSON.parse(text) : null
+    payload = rawText ? JSON.parse(rawText) : null
   } catch (error) {
-    payload = text
+    payload = rawText
   }
 
   if (!response.ok) {
-    const message = typeof payload === "string"
-      ? payload
-      : payload?.message || JSON.stringify(payload)
-    throw new Error(`${response.status} ${message}`)
+    throw new Error(`${response.status} ${getErrorMessage(payload)}`)
   }
 
   return payload
 }
 
-async function authLogin(flags) {
-  const config = readConfig()
-  const apiBase = normalizeApiBase(flags.apiBase || config.apiBase || DEFAULT_API_BASE)
-  const credentials = await promptMissingCredentials(flags)
+function resolveByRef(items, ref, nameSelector, label) {
+  if (!ref) {
+    throw new Error(`${label} reference is required`)
+  }
 
-  if (!credentials.login || !credentials.password) {
-    throw new Error("login and password are required")
+  if (!Array.isArray(items) || items.length === 0) {
+    throw new Error(`no ${label}s found`)
   }
 
-  const signinPayload = await request({
-    method: "POST",
-    url: `${apiBase}/signin`,
-    body: {
-      email: credentials.login,
-      password: credentials.password,
-    },
-  })
+  const raw = String(ref).trim()
+  if (!raw) {
+    throw new Error(`${label} reference is required`)
+  }
 
-  const token = signinPayload?.token
-  if (!token) {
-    throw new Error("signin response does not contain token")
+  if (/^\d+$/.test(raw)) {
+    const index = Number(raw) - 1
+    if (index < 0 || index >= items.length) {
+      throw new Error(`${label} index out of range: ${raw}`)
+    }
+    return items[index]
   }
 
-  writeConfig({
-    apiBase,
-    token,
-  })
+  const exactId = items.find(item => String(item._id) === raw)
+  if (exactId) {
+    return exactId
+  }
 
-  let me
-  try {
-    me = await request({
+  const lower = raw.toLowerCase()
+  const exactNameMatches = items.filter(item => String(nameSelector(item)).toLowerCase() === lower)
+  if (exactNameMatches.length === 1) {
+    return exactNameMatches[0]
+  }
+  if (exactNameMatches.length > 1) {
+    throw new Error(`ambiguous ${label} name "${raw}"`)
+  }
+
+  const partialMatches = items.filter(item => String(nameSelector(item)).toLowerCase().includes(lower))
+  if (partialMatches.length === 1) {
+    return partialMatches[0]
+  }
+  if (partialMatches.length > 1) {
+    throw new Error(`ambiguous ${label} reference "${raw}"`)
+  }
+
+  throw new Error(`${label} not found: ${raw}`)
+}
+
+async function fetchProjects(config, teamId = null) {
+  if (teamId) {
+    const payload = await request({
+      apiBase: normalizeApiBase(config.apiBase),
+      token: config.token,
       method: "GET",
-      url: `${apiBase}/me`,
-      token,
+      path: `/teams/${teamId}/projects`,
     })
-  } catch (error) {
-    me = null
+
+    return payload?.data?.projects || []
   }
 
-  printWelcomeBanner()
+  const payload = await request({
+    apiBase: normalizeApiBase(config.apiBase),
+    token: config.token,
+    method: "GET",
+    path: "/projects",
+  })
 
-  if (me?.email) {
-    console.log(`Logged in as ${me.email}`)
-  } else {
-    console.log("Logged in")
-  }
-  console.log(`Config saved: ${CONFIG_FILE}`)
+  return payload?.projects || []
 }
 
-function authLogout() {
-  const config = readConfig()
-  writeConfig({
-    apiBase: normalizeApiBase(config.apiBase || DEFAULT_API_BASE),
-    token: null,
+async function fetchProjectById(config, projectId) {
+  return request({
+    apiBase: normalizeApiBase(config.apiBase),
+    token: config.token,
+    method: "GET",
+    path: `/projects/${projectId}`,
   })
-  console.log("Logged out")
 }
 
-async function authWhoAmI() {
-  const config = readConfig()
-  const token = config.token
+async function fetchStages(config, projectId) {
+  const payload = await request({
+    apiBase: normalizeApiBase(config.apiBase),
+    token: config.token,
+    method: "GET",
+    path: `/projects/${projectId}/stages`,
+  })
 
-  if (!token) {
-    throw new Error("not logged in. run: unit-labs auth login")
-  }
+  return Array.isArray(payload) ? payload : []
+}
+
+async function fetchCurrentUser(config) {
+  return request({
+    apiBase: normalizeApiBase(config.apiBase),
+    token: config.token,
+    method: "GET",
+    path: "/me",
+  })
+}
 
-  const me = await request({
+async function fetchTeamMembers(config, teamId) {
+  const payload = await request({
+    apiBase: normalizeApiBase(config.apiBase),
+    token: config.token,
     method: "GET",
-    url: `${normalizeApiBase(config.apiBase || DEFAULT_API_BASE)}/me`,
-    token,
+    path: `/teams/${teamId}/members`,
   })
 
-  console.log(JSON.stringify(me, null, 2))
+  return payload?.data?.members || []
 }
 
-function configShow() {
-  const config = readConfig()
-  console.log(JSON.stringify({
-    apiBase: normalizeApiBase(config.apiBase || DEFAULT_API_BASE),
-    loggedIn: Boolean(config.token),
-  }, null, 2))
+async function fetchFlatTasks(config, projectId) {
+  const payload = await request({
+    apiBase: normalizeApiBase(config.apiBase),
+    token: config.token,
+    method: "GET",
+    path: `/projects/${projectId}/tasks`,
+  })
+
+  return Array.isArray(payload) ? payload : []
+}
+
+async function fetchStageTasks(config, projectId, stageId) {
+  const payload = await request({
+    apiBase: normalizeApiBase(config.apiBase),
+    token: config.token,
+    method: "GET",
+    path: `/projects/${projectId}/stages/${stageId}/tasks`,
+  })
+
+  return Array.isArray(payload) ? payload : []
 }
 
-function configSetApi(rawApi) {
-  if (!rawApi) {
-    throw new Error("api url is required. usage: unit-labs config set-api <url>")
+async function resolveProjectContext(config, projectRef, requireProject = true) {
+  const projects = await fetchProjects(config)
+  let project = null
+
+  if (projectRef) {
+    project = resolveByRef(projects, projectRef, p => p.project_name, "project")
+  } else if (config.currentProjectId) {
+    project = projects.find(p => String(p._id) === String(config.currentProjectId)) || null
   }
 
-  const config = readConfig()
-  const apiBase = normalizeApiBase(rawApi)
-  writeConfig({
-    apiBase,
-    token: config.token || null,
-  })
-  console.log(`API saved: ${apiBase}`)
+  if (!project && requireProject) {
+    throw new Error("no project selected. run: unit-labs project ls && unit-labs project use <number|name>")
+  }
+
+  return { project, projects }
 }
 
-async function run(argv) {
-  if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
-    console.log(HELP_TEXT.trim())
+async function resolveStageContext(config, project, stageRef, requireStage = true) {
+  if (!project) {
+    throw new Error("project is required")
+  }
+
+  if ((project.workflow_type || "stages") === "flat") {
+    throw new Error("this project uses flat workflow. stage commands are unavailable")
+  }
+
+  const stages = await fetchStages(config, project._id)
+  let stage = null
+
+  if (stageRef) {
+    stage = resolveByRef(stages, stageRef, s => s.stage_name, "stage")
+  } else if (config.currentStageId) {
+    stage = stages.find(s => String(s._id) === String(config.currentStageId)) || null
+  }
+
+  if (!stage && requireStage) {
+    throw new Error("no stage selected. run: unit-labs stage ls && unit-labs stage use <number|name>")
+  }
+
+  return { stage, stages }
+}
+
+async function resolveAssigneeUserId(config, project, assigneeRef) {
+  const raw = String(assigneeRef || "").trim()
+  if (!raw) {
+    throw new Error("assignee reference is required. use: unit-labs task assign <task> <me|none|number|username|email|id>")
+  }
+
+  const normalized = raw.toLowerCase()
+  if (ASSIGNEE_CLEAR_REFS.has(normalized)) {
+    return { userId: null, label: "none" }
+  }
+
+  if (ASSIGNEE_SELF_REFS.has(normalized)) {
+    const me = await fetchCurrentUser(config)
+    const meId = me?.id || me?._id
+    if (!meId) {
+      throw new Error("failed to resolve current user id from /me")
+    }
+    return {
+      userId: String(meId),
+      label: me?.email || me?.username || String(meId),
+    }
+  }
+
+  if (project.team_id) {
+    const members = await fetchTeamMembers(config, project.team_id)
+    const member = resolveMemberByRef(members, raw)
+    const memberId = member?.id || member?._id
+    if (!memberId) {
+      throw new Error("failed to resolve member id")
+    }
+    return {
+      userId: String(memberId),
+      label: member?.email || member?.username || String(memberId),
+    }
+  }
+
+  const me = await fetchCurrentUser(config)
+  const meId = me?.id || me?._id
+  const meEmail = String(me?.email || "").toLowerCase()
+  const meUsername = String(me?.username || "").toLowerCase()
+  const matchesMe = [String(meId || ""), meEmail, meUsername].includes(normalized)
+  if (!matchesMe) {
+    throw new Error("for personal project assignee can only be project owner (use `me`)")
+  }
+
+  return {
+    userId: String(meId),
+    label: me?.email || me?.username || String(meId),
+  }
+}
+
+function saveConfigPatch(config, patch) {
+  const next = {
+    ...config,
+    ...patch,
+  }
+  writeConfig(next)
+  return next
+}
+
+async function promptMissingCredentials({ login, password }) {
+  if (login && password) {
+    return { login, password }
+  }
+
+  const rl = readline.createInterface({ input, output })
+  const nextLogin = login || (await rl.question("Login: ")).trim()
+  const nextPassword = password || (await rl.question("Password: ")).trim()
+  rl.close()
+
+  return {
+    login: nextLogin,
+    password: nextPassword,
+  }
+}
+
+async function runAuth(command, args, config) {
+  const { flags } = parseArgs(args, { l: "login", e: "login", p: "password", h: "help" })
+  const apiBase = normalizeApiBase(flags.api || config.apiBase || DEFAULT_API_BASE)
+
+  if (!command || command === "--help" || command === "-h" || flags.help) {
+    console.log(AUTH_HELP.trim())
     return
   }
 
-  const [scope, command, ...rest] = argv
+  if (command === "login") {
+    const credentials = await promptMissingCredentials(flags)
+    if (!credentials.login || !credentials.password) {
+      throw new Error("login and password are required")
+    }
 
-  if (scope === "auth") {
-    const flags = parseFlags(rest)
+    const signinPayload = await request({
+      apiBase,
+      method: "POST",
+      path: "/signin",
+      body: { email: credentials.login, password: credentials.password },
+      requiresAuth: false,
+    })
+
+    const token = signinPayload?.token
+    if (!token) {
+      throw new Error("signin response does not contain token")
+    }
+
+    let me = null
+    try {
+      me = await request({
+        apiBase,
+        token,
+        method: "GET",
+        path: "/me",
+      })
+    } catch (error) {
+      me = null
+    }
+
+    saveConfigPatch(config, {
+      apiBase,
+      token,
+    })
+
+    printWelcomeBanner()
+    if (me?.email) {
+      console.log(`Logged in as ${me.email}`)
+    } else {
+      console.log("Logged in")
+    }
+    console.log(`Config saved: ${CONFIG_FILE}`)
+    return
+  }
+
+  if (command === "logout") {
+    saveConfigPatch(config, { token: null })
+    console.log("Logged out")
+    return
+  }
+
+  if (command === "whoami") {
+    const me = await request({
+      apiBase,
+      token: config.token,
+      method: "GET",
+      path: "/me",
+    })
+    printJson(me)
+    return
+  }
+
+  throw new Error(`unknown auth command: ${command}`)
+}
+
+async function runConfig(command, args, config) {
+  const { flags, positionals } = parseArgs(args, { h: "help" })
+
+  if (!command || command === "--help" || command === "-h" || flags.help) {
+    console.log(CONFIG_HELP.trim())
+    return
+  }
+
+  if (command === "show") {
+    printJson({
+      apiBase: normalizeApiBase(config.apiBase || DEFAULT_API_BASE),
+      loggedIn: Boolean(config.token),
+      currentProjectId: config.currentProjectId,
+      currentProjectName: config.currentProjectName,
+      currentProjectWorkflow: config.currentProjectWorkflow,
+      currentStageId: config.currentStageId,
+      currentStageName: config.currentStageName,
+    })
+    return
+  }
+
+  if (command === "set-api") {
+    const rawApi = positionals[0] || flags.api
+    if (!rawApi) {
+      throw new Error("api url is required. usage: unit-labs config set-api <url>")
+    }
+    const apiBase = normalizeApiBase(rawApi)
+    saveConfigPatch(config, { apiBase })
+    console.log(`API saved: ${apiBase}`)
+    return
+  }
+
+  throw new Error(`unknown config command: ${command}`)
+}
+
+async function runProject(command, args, config) {
+  const { flags, positionals } = parseArgs(args, { t: "team", w: "workflow", n: "name", j: "json", h: "help" })
+
+  if (!command || command === "--help" || command === "-h" || flags.help) {
+    console.log(PROJECT_HELP.trim())
+    return
+  }
+
+  if (command === "ls") {
+    const projects = await fetchProjects(config, flags.team || null)
+
+    if (flags.json) {
+      printJson(projects)
+      return
+    }
+
+    printProjects(projects, config.currentProjectId)
+    return
+  }
+
+  if (command === "new") {
+    const name = (flags.name || positionals.join(" ")).trim()
+    if (!name) {
+      throw new Error("project name is required. use: --name \"...\"")
+    }
+
+    const workflow = (flags.workflow || "stages").trim()
+    if (!["stages", "flat"].includes(workflow)) {
+      throw new Error("workflow must be one of: stages, flat")
+    }
+
+    const body = {
+      project_name: name,
+      workflow_type: workflow,
+    }
+    if (flags.team) {
+      body.team_id = flags.team
+    }
+
+    const payload = await request({
+      apiBase: normalizeApiBase(config.apiBase),
+      token: config.token,
+      method: "POST",
+      path: "/projects",
+      body,
+    })
+
+    if (typeof payload === "string") {
+      console.log(payload)
+    } else {
+      printJson(payload)
+    }
+    return
+  }
+
+  if (command === "view") {
+    const ref = positionals[0]
+    const { project } = await resolveProjectContext(config, ref, true)
+
+    let data = project
+    try {
+      data = await fetchProjectById(config, project._id)
+    } catch (error) {
+      data = project
+    }
 
-    if (command === "login") {
-      await authLogin(flags)
+    if (flags.json) {
+      printJson(data)
       return
     }
 
-    if (command === "logout") {
-      authLogout()
+    console.log(`Name: ${data.project_name}`)
+    console.log(`Workflow: ${data.workflow_type || "stages"}`)
+    console.log(`Status: ${data.status || "-"}`)
+    console.log(`ID: ${data._id}`)
+    return
+  }
+
+  if (command === "use") {
+    const ref = positionals[0]
+    if (!ref) {
+      throw new Error("project reference is required. use: unit-labs project use <number|name|id>")
+    }
+
+    const { project } = await resolveProjectContext(config, ref, true)
+    const workflow = project.workflow_type || "stages"
+    saveConfigPatch(config, {
+      currentProjectId: project._id,
+      currentProjectName: project.project_name,
+      currentProjectWorkflow: workflow,
+      currentStageId: null,
+      currentStageName: null,
+    })
+    console.log(`Current project: ${project.project_name} [${workflow}]`)
+    return
+  }
+
+  if (command === "current") {
+    if (!config.currentProjectId) {
+      throw new Error("no current project. use: unit-labs project use <number|name>")
+    }
+
+    const { project } = await resolveProjectContext(config, null, true)
+
+    if (flags.json) {
+      printJson(project)
       return
     }
 
-    if (command === "whoami") {
-      await authWhoAmI()
+    console.log(`Current project: ${project.project_name}`)
+    console.log(`Workflow: ${project.workflow_type || "stages"}`)
+    console.log(`ID: ${project._id}`)
+    return
+  }
+
+  throw new Error(`unknown project command: ${command}`)
+}
+
+async function runStage(command, args, config) {
+  const { flags, positionals } = parseArgs(args, {
+    p: "project",
+    n: "name",
+    d: "description",
+    j: "json",
+    h: "help",
+  })
+
+  if (!command || command === "--help" || command === "-h" || flags.help) {
+    console.log(STAGE_HELP.trim())
+    return
+  }
+
+  const projectRef = flags.project || null
+  const { project } = await resolveProjectContext(config, projectRef, true)
+  if ((project.workflow_type || "stages") === "flat") {
+    throw new Error("this project uses flat workflow. stage commands are unavailable")
+  }
+
+  if (command === "ls") {
+    const stages = await fetchStages(config, project._id)
+    if (flags.json) {
+      printJson(stages)
       return
     }
+    printStages(stages, config.currentStageId)
+    return
+  }
+
+  if (command === "new") {
+    const stageName = (flags.name || "").trim()
+    const description = (flags.description || "").trim()
+
+    if (!stageName || !description) {
+      throw new Error("stage name and description are required. use: --name \"...\" --description \"...\"")
+    }
 
-    throw new Error(`unknown auth command: ${command}`)
+    const payload = await request({
+      apiBase: normalizeApiBase(config.apiBase),
+      token: config.token,
+      method: "POST",
+      path: `/projects/${project._id}/stages`,
+      body: {
+        stage_name: stageName,
+        description,
+      },
+    })
+
+    if (typeof payload === "string") {
+      console.log(payload)
+    } else {
+      printJson(payload)
+    }
+    return
   }
 
-  if (scope === "config") {
-    if (command === "show") {
-      configShow()
+  if (command === "use") {
+    const ref = positionals[0]
+    if (!ref) {
+      throw new Error("stage reference is required. use: unit-labs stage use <number|name|id>")
+    }
+
+    const { stage } = await resolveStageContext(config, project, ref, true)
+    saveConfigPatch(config, {
+      currentProjectId: project._id,
+      currentProjectName: project.project_name,
+      currentProjectWorkflow: project.workflow_type || "stages",
+      currentStageId: stage._id,
+      currentStageName: stage.stage_name,
+    })
+    console.log(`Current stage: ${stage.stage_name}`)
+    return
+  }
+
+  if (command === "current") {
+    if (!config.currentStageId) {
+      throw new Error("no current stage. use: unit-labs stage use <number|name>")
+    }
+
+    const { stage } = await resolveStageContext(config, project, null, true)
+    if (flags.json) {
+      printJson(stage)
+      return
+    }
+    console.log(`Current stage: ${stage.stage_name}`)
+    console.log(`Status: ${stage.status || "-"}`)
+    console.log(`ID: ${stage._id}`)
+    return
+  }
+
+  throw new Error(`unknown stage command: ${command}`)
+}
+
+async function resolveTaskContext(config, flags, requireStage = true) {
+  const projectRef = flags.project || null
+  const { project } = await resolveProjectContext(config, projectRef, true)
+  const workflow = project.workflow_type || "stages"
+
+  if (workflow === "flat") {
+    return { project, workflow, stage: null }
+  }
+
+  const stageRef = flags.stage || null
+  const { stage } = await resolveStageContext(config, project, stageRef, requireStage)
+  return { project, workflow, stage }
+}
+
+async function listAllStageTasks(config, project) {
+  const stages = await fetchStages(config, project._id)
+  const result = []
+
+  for (const stage of stages) {
+    const tasks = await fetchStageTasks(config, project._id, stage._id)
+    tasks.forEach(task => {
+      result.push({
+        ...task,
+        _stageName: stage.stage_name,
+        _stageId: stage._id,
+      })
+    })
+  }
+
+  return result
+}
+
+async function runTask(command, args, config) {
+  const { flags, positionals } = parseArgs(args, {
+    p: "project",
+    s: "stage",
+    t: "title",
+    a: "all",
+    j: "json",
+    h: "help",
+  })
+
+  if (!command || command === "--help" || command === "-h" || flags.help) {
+    console.log(TASK_HELP.trim())
+    return
+  }
+
+  if (command === "ls") {
+    const { project, workflow, stage } = await resolveTaskContext(config, flags, !flags.all)
+
+    if (workflow === "flat") {
+      const tasks = await fetchFlatTasks(config, project._id)
+      if (flags.json) {
+        printJson(tasks)
+        return
+      }
+      printTasks(tasks, false)
+      return
+    }
+
+    if (flags.all) {
+      const tasks = await listAllStageTasks(config, project)
+      if (flags.json) {
+        printJson(tasks)
+        return
+      }
+      printTasks(tasks, true)
       return
     }
 
-    if (command === "set-api") {
-      configSetApi(rest[0])
+    const tasks = await fetchStageTasks(config, project._id, stage._id)
+    if (flags.json) {
+      printJson(tasks)
+      return
+    }
+    printTasks(tasks, false)
+    return
+  }
+
+  if (command === "new") {
+    const title = (flags.title || positionals.join(" ")).trim()
+    if (!title) {
+      throw new Error("task title is required. use: unit-labs task new \"Task title\"")
+    }
+
+    const { project, workflow, stage } = await resolveTaskContext(config, flags, true)
+
+    const path = workflow === "flat"
+      ? `/projects/${project._id}/tasks`
+      : `/projects/${project._id}/stages/${stage._id}/tasks`
+
+    const payload = await request({
+      apiBase: normalizeApiBase(config.apiBase),
+      token: config.token,
+      method: "POST",
+      path,
+      body: { title },
+    })
+
+    if (Array.isArray(payload)) {
+      printTasks(payload, false)
+    } else if (typeof payload === "string") {
+      console.log(payload)
+    } else {
+      printJson(payload)
+    }
+    return
+  }
+
+  if (command === "done" || command === "close") {
+    const taskRef = positionals[0]
+    if (!taskRef) {
+      throw new Error("task reference is required. use: unit-labs task done <number|title|id>")
+    }
+
+    const { project, workflow, stage } = await resolveTaskContext(config, flags, true)
+    const tasks = workflow === "flat"
+      ? await fetchFlatTasks(config, project._id)
+      : await fetchStageTasks(config, project._id, stage._id)
+    const task = resolveByRef(tasks, taskRef, t => t.title, "task")
+
+    const path = workflow === "flat"
+      ? `/projects/${project._id}/tasks/${task._id}/toggle`
+      : `/projects/${project._id}/stages/${stage._id}/tasks/${task._id}/toggle`
+
+    const updated = await request({
+      apiBase: normalizeApiBase(config.apiBase),
+      token: config.token,
+      method: "PATCH",
+      path,
+    })
+
+    printTasks([updated], false)
+    return
+  }
+
+  if (command === "assign" || command === "unassign") {
+    const taskRef = positionals[0]
+    const assigneeRef = command === "unassign" ? "none" : positionals[1]
+
+    if (!taskRef) {
+      throw new Error("task reference is required. use: unit-labs task assign <number|title|id> <assignee>")
+    }
+    if (!assigneeRef) {
+      throw new Error("assignee reference is required. use: unit-labs task assign <task> <me|none|number|username|email|id>")
+    }
+
+    const { project, workflow, stage } = await resolveTaskContext(config, flags, true)
+    const tasks = workflow === "flat"
+      ? await fetchFlatTasks(config, project._id)
+      : await fetchStageTasks(config, project._id, stage._id)
+    const task = resolveByRef(tasks, taskRef, t => t.title, "task")
+    const assignee = await resolveAssigneeUserId(config, project, assigneeRef)
+
+    const path = workflow === "flat"
+      ? `/projects/${project._id}/tasks/${task._id}/assign`
+      : `/projects/${project._id}/stages/${stage._id}/tasks/${task._id}/assign`
+
+    const updated = await request({
+      apiBase: normalizeApiBase(config.apiBase),
+      token: config.token,
+      method: "PATCH",
+      path,
+      body: { user_id: assignee.userId },
+    })
+
+    if (flags.json) {
+      printJson(updated)
       return
     }
 
-    throw new Error(`unknown config command: ${command}`)
+    printTasks([updated], false)
+    if (assignee.userId) {
+      console.log(`Assigned to: ${assignee.label}`)
+    } else {
+      console.log("Assignee cleared")
+    }
+    return
+  }
+
+  if (command === "edit") {
+    const taskRef = positionals[0]
+    const title = (flags.title || positionals.slice(1).join(" ")).trim()
+
+    if (!taskRef) {
+      throw new Error("task reference is required. use: unit-labs task edit <number|title|id> --title \"...\"")
+    }
+    if (!title) {
+      throw new Error("new title is required. use: --title \"New title\"")
+    }
+
+    const { project, workflow, stage } = await resolveTaskContext(config, flags, true)
+    const tasks = workflow === "flat"
+      ? await fetchFlatTasks(config, project._id)
+      : await fetchStageTasks(config, project._id, stage._id)
+    const task = resolveByRef(tasks, taskRef, t => t.title, "task")
+
+    const path = workflow === "flat"
+      ? `/projects/${project._id}/tasks/${task._id}/title`
+      : `/projects/${project._id}/stages/${stage._id}/tasks/${task._id}/title`
+
+    const updated = await request({
+      apiBase: normalizeApiBase(config.apiBase),
+      token: config.token,
+      method: "PATCH",
+      path,
+      body: { title },
+    })
+
+    printTasks([updated], false)
+    return
+  }
+
+  if (command === "rm" || command === "delete") {
+    const taskRef = positionals[0]
+    if (!taskRef) {
+      throw new Error("task reference is required. use: unit-labs task rm <number|title|id>")
+    }
+
+    const { project, workflow, stage } = await resolveTaskContext(config, flags, true)
+    const tasks = workflow === "flat"
+      ? await fetchFlatTasks(config, project._id)
+      : await fetchStageTasks(config, project._id, stage._id)
+    const task = resolveByRef(tasks, taskRef, t => t.title, "task")
+
+    const path = workflow === "flat"
+      ? `/projects/${project._id}/tasks/${task._id}`
+      : `/projects/${project._id}/stages/${stage._id}/tasks/${task._id}`
+
+    await request({
+      apiBase: normalizeApiBase(config.apiBase),
+      token: config.token,
+      method: "DELETE",
+      path,
+    })
+
+    console.log(`Deleted task: ${task.title}`)
+    return
+  }
+
+  throw new Error(`unknown task command: ${command}`)
+}
+
+async function run(argv) {
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    console.log(ROOT_HELP.trim())
+    return
+  }
+
+  const [scope, command, ...rest] = argv
+  const config = readConfig()
+
+  if (scope === "auth") {
+    await runAuth(command, rest, config)
+    return
+  }
+
+  if (scope === "config") {
+    await runConfig(command, rest, config)
+    return
+  }
+
+  if (scope === "project") {
+    await runProject(command, rest, config)
+    return
+  }
+
+  if (scope === "stage") {
+    await runStage(command, rest, config)
+    return
+  }
+
+  if (scope === "task") {
+    await runTask(command, rest, config)
+    return
   }
 
   throw new Error(`unknown scope: ${scope}`)
@@ -264,4 +1147,3 @@ async function run(argv) {
 module.exports = {
   run,
 }
-