nikcli 0.0.6

package/src/session/todo.ts

@@ -0,0 +1,258 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import os from "os"
+import path from "path"
+import { fileURLToPath } from "url"
+import z from "zod"
+import { Storage } from "../storage/storage"
+import { Config } from "../config/config"
+import { resolveCredential } from "../connectors/credentials"
+import { Log } from "../util/log"
+import { Flag } from "../flag/flag"
+
+const log = Log.create({ service: "todo-notifications" })
+
+type MacIcon = {
+  value: string
+  remote: boolean
+}
+
+export namespace Todo {
+  export const Info = z
+    .object({
+      content: z.string().describe("Brief description of the task"),
+      status: z.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
+      priority: z.string().describe("Priority level of the task: high, medium, low"),
+      id: z.string().describe("Unique identifier for the todo item"),
+    })
+    .meta({ ref: "Todo" })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Updated: BusEvent.define(
+      "todo.updated",
+      z.object({
+        sessionID: z.string(),
+        todos: z.array(Info),
+        diff: z.object({
+          added: z.array(Info),
+          completed: z.array(Info),
+        }),
+      }),
+    ),
+  }
+
+  function done(status: string) {
+    return status === "completed" || status === "cancelled"
+  }
+
+  function diff(prev: Info[], next: Info[]) {
+    const prevMap = new Map(prev.map((todo) => [todo.id, todo]))
+    const added = next.filter((todo) => !prevMap.has(todo.id))
+    const completed = next.filter((todo) => {
+      if (!done(todo.status)) return false
+      const old = prevMap.get(todo.id)
+      if (!old) return false
+      return !done(old.status)
+    })
+    return { added, completed }
+  }
+
+  export async function update(input: { sessionID: string; todos: Info[] }) {
+    const prev = await get(input.sessionID)
+    const change = diff(prev, input.todos)
+    await Storage.write(["todo", input.sessionID], input.todos)
+    Bus.publish(Event.Updated, { ...input, diff: change })
+  }
+
+  export async function get(sessionID: string) {
+    return Storage.read<Info[]>(["todo", sessionID])
+      .then((todo) => todo || [])
+      .catch(() => [])
+  }
+
+  type ConnectorEntry = NonNullable<Config.Info["connectors"]>[string]
+
+  function isConnector(entry: ConnectorEntry | undefined): entry is Config.Connector {
+    return typeof entry === "object" && entry !== null && "type" in entry
+  }
+
+  function list(todos: Info[]) {
+    return todos.map((todo) => `- ${todo.content} (${todo.priority})`).join("\n")
+  }
+
+  function iconPath(value: string) {
+    if (!value) return undefined
+    if (value === "~") return os.homedir()
+    if (value.startsWith("~/")) return path.join(os.homedir(), value.slice(2))
+    if (value.startsWith("file://")) return fileURLToPath(value)
+    if (path.isAbsolute(value)) return value
+    return undefined
+  }
+
+  function iconMac(config: Config.Info): MacIcon | undefined {
+    const icon = config.notifications?.icon
+    if (!icon) return undefined
+    const value = icon.url
+    if (!value) return undefined
+    if (value.startsWith("http://") || value.startsWith("https://")) {
+      return { value, remote: true }
+    }
+    const local = iconPath(value)
+    if (!local) return undefined
+    return { value: local, remote: false }
+  }
+
+  async function macos(config: Config.Info, title: string, body: string) {
+    if (process.platform !== "darwin") return
+    const icon = iconMac(config)
+    const message = body.length ? body : " "
+
+    const notifier = icon && !icon.remote ? Bun.which("terminal-notifier") : null
+    if (icon && notifier && !icon.remote) {
+      const result = await Bun.$`${notifier} -title ${title} -message ${message} -contentImage ${icon.value}`
+        .nothrow()
+        .quiet()
+      if (result.exitCode === 0) return
+    }
+    if (!icon) {
+      const escapedTitle = title.replace(/"/g, '\\"')
+      const escapedBody = body.replace(/"/g, '\\"')
+      await Bun.$`osascript -e 'display notification "${escapedBody}" with title "${escapedTitle}"'`.nothrow().quiet()
+      return
+    }
+    const script = `
+      ObjC.import('Cocoa')
+      const title = ${JSON.stringify(title)}
+      const body = ${JSON.stringify(body)}
+      const image = ${JSON.stringify(icon.value)}
+      const remote = ${JSON.stringify(icon.remote)}
+      const notification = $.NSUserNotification.alloc.init
+      notification.title = title
+      notification.informativeText = body
+      const url = remote ? $.NSURL.URLWithString(image) : $.NSURL.fileURLWithPath(image)
+      const img = $.NSImage.alloc.initWithContentsOfURL(url)
+      if (!img) throw new Error('icon load failed')
+      notification.contentImage = img
+      const center = $.NSUserNotificationCenter.defaultUserNotificationCenter
+      center.deliverNotification(notification)
+      $.NSThread.sleepForTimeInterval(0.2)
+      if (!notification.presented) throw new Error('notification not presented')
+    `
+    const result = await Bun.$`osascript -l JavaScript -e ${script}`.nothrow().quiet()
+    if (result.exitCode === 0) return
+    const escapedTitle = title.replace(/"/g, '\\"')
+    const escapedBody = body.replace(/"/g, '\\"')
+    await Bun.$`osascript -e 'display notification "${escapedBody}" with title "${escapedTitle}"'`.nothrow().quiet()
+  }
+
+  async function slack(config: Config.Info, message: string) {
+    const settings = config.notifications?.todo
+    if (!settings) return
+    const cfg = settings.slack
+    if (!cfg) return
+    if (cfg.enabled === false) return
+
+    const enabled = cfg.enabled ?? Flag.NIKCLI_SLACK_TASK_NOTIFICATIONS
+    if (!enabled) return
+
+    if (!cfg.connector) return
+    const name = cfg.connector
+    const channel = cfg.channel || Flag.NIKCLI_SLACK_CHANNEL
+    if (!channel) return
+    const connectors = config.connectors ?? {}
+    const entry = connectors[name]
+    if (!isConnector(entry)) return
+    if (entry.enabled === false) return
+    if (entry.type !== "slack") return
+
+    const credential = await resolveCredential(name, entry)
+    if (!credential) return
+    const api = await import("../connectors/api/slack")
+    await api.SlackApi.sendMessage(credential, channel, message).catch((error) => {
+      const text = error instanceof Error ? error.message : String(error)
+      log.error("failed to send Slack notification", { error: text })
+    })
+  }
+
+  async function discord(config: Config.Info, message: string) {
+    const settings = config.notifications?.todo
+    if (!settings) return
+    const cfg = settings.discord
+    if (!cfg) return
+    if (cfg.enabled === false) return
+
+    const enabled = cfg.enabled ?? Flag.NIKCLI_DISCORD_TASK_NOTIFICATIONS
+    if (!enabled) return
+    const webhook = cfg.webhook || Flag.NIKCLI_DISCORD_WEBHOOK_URL
+    if (!webhook) return
+
+    await fetch(webhook, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content: message }),
+    })
+      .then(async (response) => {
+        if (response.ok) return
+        const text = await response.text().catch(() => "")
+        const detail = text ? `Discord webhook failed: ${text}` : `Discord webhook failed: ${response.status}`
+        throw new Error(detail)
+      })
+      .catch((error) => {
+        const text = error instanceof Error ? error.message : String(error)
+        log.error("failed to send Discord notification", { error: text })
+      })
+  }
+
+  async function notify(change: { added: Info[]; completed: Info[] }) {
+    const config = await Config.get()
+    const settings = config.notifications?.todo
+    if (!settings) return
+    if (settings.enabled === false) return
+
+    const envEnabled =
+      Flag.NIKCLI_TODO_NOTIFICATIONS || Flag.NIKCLI_SLACK_TASK_NOTIFICATIONS || Flag.NIKCLI_DISCORD_TASK_NOTIFICATIONS
+    const enabled = settings.enabled ?? envEnabled
+    if (!enabled) return
+
+    const added = change.added
+    const completed = change.completed
+    if (added.length === 0 && completed.length === 0) return
+
+    if (added.length > 0) {
+      const title = added.length === 1 ? "New Todo Created" : `${added.length} New Todos`
+      const body = added.length === 1 ? added[0].content : list(added)
+      const slackMessage =
+        added.length === 1 ? `New todo: ${added[0].content}` : `${added.length} new todos:\n${list(added)}`
+      const discordMessage = slackMessage
+
+      if (settings.macos === true) {
+        await macos(config, title, body).catch(() => {})
+      }
+      await slack(config, slackMessage)
+      await discord(config, discordMessage)
+    }
+
+    if (completed.length > 0) {
+      const title = completed.length === 1 ? "Todo Completed" : `${completed.length} Todos Completed`
+      const body = completed.length === 1 ? completed[0].content : list(completed)
+      const slackMessage =
+        completed.length === 1
+          ? `Completed: ${completed[0].content}`
+          : `${completed.length} todos completed:\n${list(completed)}`
+      const discordMessage = slackMessage
+
+      if (settings.macos === true) {
+        await macos(config, title, body).catch(() => {})
+      }
+      await slack(config, slackMessage)
+      await discord(config, discordMessage)
+    }
+  }
+
+  export function init() {
+    Bus.subscribe(Event.Updated, async (evt) => {
+      await notify(evt.properties.diff)
+    })
+  }
+}

package/src/session/uninstall.ts

@@ -0,0 +1,357 @@
+import type { Argv } from "yargs"
+import * as prompts from "@clack/prompts"
+import { Installation } from "../installation"
+import { Global } from "../global"
+import { $ } from "bun"
+import fs from "fs/promises"
+import path from "path"
+import os from "os"
+import { UI } from "@/cli/ui"
+
+interface UninstallArgs {
+  keepConfig: boolean
+  keepData: boolean
+  dryRun: boolean
+  force: boolean
+}
+
+interface RemovalTargets {
+  directories: Array<{ path: string; label: string; keep: boolean }>
+  shellConfig: string | null
+  binary: string | null
+}
+
+export const UninstallCommand = {
+  command: "uninstall",
+  describe: "uninstall nikcli and remove all related files",
+  builder: (yargs: Argv) =>
+    yargs
+      .option("keep-config", {
+        alias: "c",
+        type: "boolean",
+        describe: "keep configuration files",
+        default: false,
+      })
+      .option("keep-data", {
+        alias: "d",
+        type: "boolean",
+        describe: "keep session data and snapshots",
+        default: false,
+      })
+      .option("dry-run", {
+        type: "boolean",
+        describe: "show what would be removed without removing",
+        default: false,
+      })
+      .option("force", {
+        alias: "f",
+        type: "boolean",
+        describe: "skip confirmation prompts",
+        default: false,
+      }),
+
+  handler: async (args: UninstallArgs) => {
+    UI.empty()
+    UI.println(UI.logo("  "))
+    UI.empty()
+    prompts.intro("Uninstall Nikcli")
+
+    const method = await Installation.method()
+    prompts.log.info(`Installation method: ${method}`)
+
+    const targets = await collectRemovalTargets(args, method)
+
+    await showRemovalSummary(targets, method)
+
+    if (!args.force && !args.dryRun) {
+      const confirm = await prompts.confirm({
+        message: "Are you sure you want to uninstall?",
+        initialValue: false,
+      })
+      if (!confirm || prompts.isCancel(confirm)) {
+        prompts.outro("Cancelled")
+        return
+      }
+    }
+
+    if (args.dryRun) {
+      prompts.log.warn("Dry run - no changes made")
+      prompts.outro("Done")
+      return
+    }
+
+    await executeUninstall(method, targets)
+
+    prompts.outro("Done")
+  },
+}
+
+async function collectRemovalTargets(args: UninstallArgs, method: Installation.Method): Promise<RemovalTargets> {
+  const directories: RemovalTargets["directories"] = [
+    { path: Global.Path.data, label: "Data", keep: args.keepData },
+    { path: Global.Path.cache, label: "Cache", keep: false },
+    { path: Global.Path.config, label: "Config", keep: args.keepConfig },
+    { path: Global.Path.state, label: "State", keep: false },
+  ]
+
+  const shellConfig = method === "curl" ? await getShellConfigFile() : null
+  const binary = method === "curl" ? process.execPath : null
+
+  return { directories, shellConfig, binary }
+}
+
+async function showRemovalSummary(targets: RemovalTargets, method: Installation.Method) {
+  prompts.log.message("The following will be removed:")
+
+  for (const dir of targets.directories) {
+    const exists = await fs
+      .access(dir.path)
+      .then(() => true)
+      .catch(() => false)
+    if (!exists) continue
+
+    const size = await getDirectorySize(dir.path)
+    const sizeStr = formatSize(size)
+    const status = dir.keep ? UI.Style.TEXT_DIM + "(keeping)" : ""
+    const prefix = dir.keep ? "○" : "✓"
+
+    prompts.log.info(`  ${prefix} ${dir.label}: ${shortenPath(dir.path)} ${UI.Style.TEXT_DIM}(${sizeStr})${status}`)
+  }
+
+  if (targets.binary) {
+    prompts.log.info(`  ✓ Binary: ${shortenPath(targets.binary)}`)
+  }
+
+  if (targets.shellConfig) {
+    prompts.log.info(`  ✓ Shell PATH in ${shortenPath(targets.shellConfig)}`)
+  }
+
+  if (method !== "curl" && method !== "unknown") {
+    const cmds: Record<string, string> = {
+      npm: "npm uninstall -g nikcli-ai",
+      pnpm: "pnpm uninstall -g nikcli-ai",
+      bun: "bun remove -g nikcli-ai",
+      yarn: "yarn global remove nikcli-ai",
+      brew: "brew uninstall nikcli",
+      choco: "choco uninstall nikcli",
+      scoop: "scoop uninstall nikcli",
+    }
+    prompts.log.info(`  ✓ Package: ${cmds[method] || method}`)
+  }
+}
+
+async function executeUninstall(method: Installation.Method, targets: RemovalTargets) {
+  const spinner = prompts.spinner()
+  const errors: string[] = []
+
+  for (const dir of targets.directories) {
+    if (dir.keep) {
+      prompts.log.step(`Skipping ${dir.label} (--keep-${dir.label.toLowerCase()})`)
+      continue
+    }
+
+    const exists = await fs
+      .access(dir.path)
+      .then(() => true)
+      .catch(() => false)
+    if (!exists) continue
+
+    spinner.start(`Removing ${dir.label}...`)
+    const err = await fs.rm(dir.path, { recursive: true, force: true }).catch((e) => e)
+    if (err) {
+      spinner.stop(`Failed to remove ${dir.label}`, 1)
+      errors.push(`${dir.label}: ${err.message}`)
+      continue
+    }
+    spinner.stop(`Removed ${dir.label}`)
+  }
+
+  if (targets.shellConfig) {
+    spinner.start("Cleaning shell config...")
+    const err = await cleanShellConfig(targets.shellConfig).catch((e) => e)
+    if (err) {
+      spinner.stop("Failed to clean shell config", 1)
+      errors.push(`Shell config: ${err.message}`)
+    } else {
+      spinner.stop("Cleaned shell config")
+    }
+  }
+
+  if (method !== "curl" && method !== "unknown") {
+    const cmds: Record<string, string[]> = {
+      npm: ["npm", "uninstall", "-g", "nikcli-ai"],
+      pnpm: ["pnpm", "uninstall", "-g", "nikcli-ai"],
+      bun: ["bun", "remove", "-g", "nikcli-ai"],
+      yarn: ["yarn", "global", "remove", "nikcli-ai"],
+      brew: ["brew", "uninstall", "nikcli"],
+      choco: ["choco", "uninstall", "nikcli"],
+      scoop: ["scoop", "uninstall", "nikcli"],
+    }
+
+    const cmd = cmds[method]
+    if (cmd) {
+      spinner.start(`Running ${cmd.join(" ")}...`)
+      const result =
+        method === "choco"
+          ? await $`echo Y | choco uninstall nikcli -y -r`.quiet().nothrow()
+          : await $`${cmd}`.quiet().nothrow()
+      if (result.exitCode !== 0) {
+        spinner.stop(`Package manager uninstall failed: exit code ${result.exitCode}`, 1)
+        if (
+          method === "choco" &&
+          result.stdout.toString("utf8").includes("not running from an elevated command shell")
+        ) {
+          prompts.log.warn(`You may need to run '${cmd.join(" ")}' from an elevated command shell`)
+        } else {
+          prompts.log.warn(`You may need to run manually: ${cmd.join(" ")}`)
+        }
+      } else {
+        spinner.stop("Package removed")
+      }
+    }
+  }
+
+  if (method === "curl" && targets.binary) {
+    UI.empty()
+    prompts.log.message("To finish removing the binary, run:")
+    prompts.log.info(`  rm "${targets.binary}"`)
+
+    const binDir = path.dirname(targets.binary)
+    if (binDir.includes(".nikcli")) {
+      prompts.log.info(`  rmdir "${binDir}" 2>/dev/null`)
+    }
+  }
+
+  if (errors.length > 0) {
+    UI.empty()
+    prompts.log.warn("Some operations failed:")
+    for (const err of errors) {
+      prompts.log.error(`  ${err}`)
+    }
+  }
+
+  UI.empty()
+  prompts.log.success("Thank you for using Nikcli!")
+}
+
+async function getShellConfigFile(): Promise<string | null> {
+  const shell = path.basename(process.env.SHELL || "bash")
+  const home = os.homedir()
+  const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(home, ".config")
+
+  const configFiles: Record<string, string[]> = {
+    fish: [path.join(xdgConfig, "fish", "config.fish")],
+    zsh: [
+      path.join(home, ".zshrc"),
+      path.join(home, ".zshenv"),
+      path.join(xdgConfig, "zsh", ".zshrc"),
+      path.join(xdgConfig, "zsh", ".zshenv"),
+    ],
+    bash: [
+      path.join(home, ".bashrc"),
+      path.join(home, ".bash_profile"),
+      path.join(home, ".profile"),
+      path.join(xdgConfig, "bash", ".bashrc"),
+      path.join(xdgConfig, "bash", ".bash_profile"),
+    ],
+    ash: [path.join(home, ".ashrc"), path.join(home, ".profile")],
+    sh: [path.join(home, ".profile")],
+  }
+
+  const candidates = configFiles[shell] || configFiles.bash
+
+  for (const file of candidates) {
+    const exists = await fs
+      .access(file)
+      .then(() => true)
+      .catch(() => false)
+    if (!exists) continue
+
+    const content = await Bun.file(file)
+      .text()
+      .catch(() => "")
+    if (content.includes("# nikcli") || content.includes(".nikcli/bin")) {
+      return file
+    }
+  }
+
+  return null
+}
+
+async function cleanShellConfig(file: string) {
+  const content = await Bun.file(file).text()
+  const lines = content.split("\n")
+
+  const filtered: string[] = []
+  let skip = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    if (trimmed === "# nikcli") {
+      skip = true
+      continue
+    }
+
+    if (skip) {
+      skip = false
+      if (trimmed.includes(".nikcli/bin") || trimmed.includes("fish_add_path")) {
+        continue
+      }
+    }
+
+    if (
+      (trimmed.startsWith("export PATH=") && trimmed.includes(".nikcli/bin")) ||
+      (trimmed.startsWith("fish_add_path") && trimmed.includes(".nikcli"))
+    ) {
+      continue
+    }
+
+    filtered.push(line)
+  }
+
+  while (filtered.length > 0 && filtered[filtered.length - 1].trim() === "") {
+    filtered.pop()
+  }
+
+  const output = filtered.join("\n") + "\n"
+  await Bun.write(file, output)
+}
+
+async function getDirectorySize(dir: string): Promise<number> {
+  let total = 0
+
+  const walk = async (current: string) => {
+    const entries = await fs.readdir(current, { withFileTypes: true }).catch(() => [])
+
+    for (const entry of entries) {
+      const full = path.join(current, entry.name)
+      if (entry.isDirectory()) {
+        await walk(full)
+        continue
+      }
+      if (entry.isFile()) {
+        const stat = await fs.stat(full).catch(() => null)
+        if (stat) total += stat.size
+      }
+    }
+  }
+
+  await walk(dir)
+  return total
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`
+}
+
+function shortenPath(p: string): string {
+  const home = os.homedir()
+  if (p.startsWith(home)) {
+    return p.replace(home, "~")
+  }
+  return p
+}