nikcli 0.0.6

package/src/chatbot/index.ts

@@ -0,0 +1,132 @@
+import { Chat, type Adapter, type Thread, type Message } from "chat"
+import { createDiscordAdapter } from "@chat-adapter/discord"
+import { createSlackAdapter } from "@chat-adapter/slack"
+import { createTeamsAdapter } from "@chat-adapter/teams"
+import { createGoogleChatAdapter } from "@chat-adapter/gchat"
+import { createLinearAdapter } from "@chat-adapter/linear"
+import { createGitHubAdapter } from "@chat-adapter/github"
+import { createMemoryState } from "@chat-adapter/state-memory"
+import { Config } from "../config/config"
+import { resolveCredential } from "../connectors/credentials"
+import { Log } from "../util/log"
+
+export namespace ChatBot {
+  const log = Log.create({ service: "chatbot" })
+
+  const bots = new Map<string, Chat>()
+
+  const CHAT_SDK_PLATFORMS = ["discord", "slack", "teams", "gchat", "linear", "github"] as const
+  type ChatPlatform = (typeof CHAT_SDK_PLATFORMS)[number]
+
+  export type BotConfig = {
+    name: string
+    platform: ChatPlatform
+    enabled: boolean
+  }
+
+  export function isChatPlatform(type: string): type is ChatPlatform {
+    return CHAT_SDK_PLATFORMS.includes(type as ChatPlatform)
+  }
+
+  export async function createBot(name: string, config: Config.Connector): Promise<Chat | null> {
+    if (!isChatPlatform(config.type)) {
+      log.warn("Invalid chat platform", { type: config.type, name })
+      return null
+    }
+
+    const existing = bots.get(name)
+    if (existing) return existing
+
+    const credential = await resolveCredential(name, config)
+    if (!credential) {
+      log.warn("No credential for bot", { name, type: config.type })
+      return null
+    }
+
+    const adapter = createAdapter(config.type, credential)
+    if (!adapter) {
+      log.warn("Failed to create adapter", { type: config.type, name })
+      return null
+    }
+
+    const bot = new Chat({
+      userName: `nikcli-${name}`,
+      adapters: { [config.type]: adapter },
+      state: createMemoryState(),
+      logger: "info",
+    })
+
+    bots.set(name, bot)
+    log.info("Bot created", { name, platform: config.type })
+
+    return bot
+  }
+
+  function createAdapter(platform: ChatPlatform, credential: string): Adapter | null {
+    switch (platform) {
+      case "discord":
+        return createDiscordAdapter({ botToken: credential })
+      case "slack":
+        return createSlackAdapter({ botToken: credential })
+      case "teams":
+        return createTeamsAdapter({ appId: credential, appPassword: credential })
+      case "gchat":
+        try {
+          const creds = JSON.parse(credential)
+          return createGoogleChatAdapter({ credentials: creds })
+        } catch {
+          return createGoogleChatAdapter()
+        }
+      case "linear":
+        return createLinearAdapter({ accessToken: credential })
+      case "github":
+        return createGitHubAdapter({ token: credential })
+      default:
+        return null
+    }
+  }
+
+  export function getBot(name: string): Chat | undefined {
+    return bots.get(name)
+  }
+
+  export function getAllBots(): Map<string, Chat> {
+    return bots
+  }
+
+  export function removeBot(name: string): boolean {
+    return bots.delete(name)
+  }
+
+  export function registerMentionHandler(
+    bot: Chat,
+    handler: (thread: Thread, message: Message) => Promise<void>,
+  ): void {
+    bot.onNewMention(async (thread, message) => {
+      await handler(thread, message)
+    })
+  }
+
+  export function registerMessageHandler(
+    bot: Chat,
+    handler: (thread: Thread, message: Message) => Promise<void>,
+  ): void {
+    bot.onSubscribedMessage(async (thread, message) => {
+      await handler(thread, message)
+    })
+  }
+
+  export function registerPatternHandler(
+    bot: Chat,
+    pattern: RegExp,
+    handler: (thread: Thread, message: Message) => Promise<void>,
+  ): void {
+    bot.onNewMessage(pattern, async (thread, message) => {
+      await handler(thread, message)
+    })
+  }
+
+  export function getWebhookPath(platform: ChatPlatform, connectorName: string): string {
+    return `/chatbot/${platform}/${connectorName}`
+  }
+}

package/src/cli/bootstrap.ts

@@ -0,0 +1,17 @@
+import { InstanceBootstrap } from "../project/bootstrap"
+import { Instance } from "../project/instance"
+
+export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
+  return Instance.provide({
+    directory,
+    init: InstanceBootstrap,
+    fn: async () => {
+      try {
+        const result = await cb()
+        return result
+      } finally {
+        await Instance.dispose()
+      }
+    },
+  })
+}

package/src/cli/cmd/acp.ts

@@ -0,0 +1,69 @@
+import { Log } from "@/util/log"
+import { bootstrap } from "../bootstrap"
+import { cmd } from "./cmd"
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
+import { ACP } from "@/acp/agent"
+import { Server } from "@/server/server"
+import { createNikcliClient } from "@nikcli-ai/sdk/v2"
+import { withNetworkOptions, resolveNetworkOptions } from "../network"
+
+const log = Log.create({ service: "acp-command" })
+
+export const AcpCommand = cmd({
+  command: "acp",
+  describe: "start ACP (Agent Client Protocol) server",
+  builder: (yargs) => {
+    return withNetworkOptions(yargs).option("cwd", {
+      describe: "working directory",
+      type: "string",
+      default: process.cwd(),
+    })
+  },
+  handler: async (args) => {
+    await bootstrap(process.cwd(), async () => {
+      const opts = await resolveNetworkOptions(args)
+      const server = Server.listen(opts)
+
+      const sdk = createNikcliClient({
+        baseUrl: `http://${server.hostname}:${server.port}`,
+      })
+
+      const input = new WritableStream<Uint8Array>({
+        write(chunk) {
+          return new Promise<void>((resolve, reject) => {
+            process.stdout.write(chunk, (err) => {
+              if (err) {
+                reject(err)
+              } else {
+                resolve()
+              }
+            })
+          })
+        },
+      })
+      const output = new ReadableStream<Uint8Array>({
+        start(controller) {
+          process.stdin.on("data", (chunk: Buffer) => {
+            controller.enqueue(new Uint8Array(chunk))
+          })
+          process.stdin.on("end", () => controller.close())
+          process.stdin.on("error", (err) => controller.error(err))
+        },
+      })
+
+      const stream = ndJsonStream(input, output)
+      const agent = await ACP.init({ sdk })
+
+      new AgentSideConnection((conn) => {
+        return agent.create(conn, { sdk })
+      }, stream)
+
+      log.info("setup connection")
+      process.stdin.resume()
+      await new Promise((resolve, reject) => {
+        process.stdin.on("end", resolve)
+        process.stdin.on("error", reject)
+      })
+    })
+  },
+})

package/src/cli/cmd/ads.ts

@@ -0,0 +1,377 @@
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { Config } from "../../config/config"
+import { Instance } from "../../project/instance"
+import { Locale } from "../../util/locale"
+import type { Argv } from "yargs"
+
+type AdsConfig = Config.Ads
+type AdsItem = Config.AdsItem
+
+function slug(input: string) {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+/, "")
+    .replace(/-+$/, "")
+}
+
+function suggestId(text: string, items: AdsItem[]) {
+  const base = slug(text) || "ad"
+  const matches = items.filter((item) => item.id === base || item.id.startsWith(base + "-")).length
+  return matches === 0 ? base : `${base}-${matches + 1}`
+}
+
+function validateUrl(value: string | undefined) {
+  if (!value) return undefined
+  try {
+    new URL(value)
+    return undefined
+  } catch {
+    return "Enter a valid URL (https://...)"
+  }
+}
+
+function normalizeUrl(value: string) {
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : undefined
+}
+
+async function loadAds(): Promise<AdsConfig> {
+  const config = await Config.getGlobal()
+  return config.ads ?? {}
+}
+
+async function saveAds(next: AdsConfig): Promise<void> {
+  await Config.updateGlobal({ ads: next })
+}
+
+async function selectId(items: AdsItem[], value: string | undefined, message: string) {
+  const provided = value?.trim()
+  if (provided) return provided
+
+  const options = items.map((item) => ({
+    label: item.id,
+    value: item.id,
+    hint: Locale.truncate(item.text, 60),
+  }))
+
+  const selected = await prompts.select({
+    message,
+    options,
+  })
+  if (prompts.isCancel(selected)) throw new UI.CancelledError()
+  return selected
+}
+
+export const AdsCommand = cmd({
+  command: "ads",
+  describe: "manage ads",
+  builder: (yargs) =>
+    yargs
+      .command(AdsCreateCommand)
+      .command(AdsListCommand)
+      .command(AdsRemoveCommand)
+      .command(AdsToggleCommand)
+      .command(AdsEnableCommand)
+      .command(AdsDisableCommand)
+      .demandCommand(),
+  async handler() {},
+})
+
+export const AdsCreateCommand = cmd({
+  command: "create",
+  describe: "create a new ad",
+  builder: (yargs: Argv) =>
+    yargs
+      .option("id", {
+        type: "string",
+        describe: "ad identifier",
+      })
+      .option("text", {
+        type: "string",
+        describe: "ad text",
+      })
+      .option("url", {
+        type: "string",
+        describe: "optional URL",
+      })
+      .option("disabled", {
+        type: "boolean",
+        describe: "create the ad as disabled",
+      }),
+  async handler(args) {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Create ad")
+
+        const ads = await loadAds()
+        const items = ads.items ?? []
+
+        const textInput = await (async () => {
+          if (typeof args.text === "string") return args.text
+          const value = await prompts.text({
+            message: "Ad text",
+            validate: (input) => (input && input.trim().length > 0 ? undefined : "Required"),
+          })
+          if (prompts.isCancel(value)) throw new UI.CancelledError()
+          return value
+        })()
+
+        const text = textInput.trim()
+        if (!text) {
+          prompts.log.error("Ad text is required")
+          prompts.outro("Done")
+          return
+        }
+
+        const suggestion = suggestId(text, items)
+        const idInput = await (async () => {
+          if (typeof args.id === "string") return args.id
+          const value = await prompts.text({
+            message: `Identifier (optional, default: ${suggestion})`,
+          })
+          if (prompts.isCancel(value)) throw new UI.CancelledError()
+          return value
+        })()
+
+        const id = slug(idInput || "") || suggestion
+        const exists = items.some((item) => item.id === id)
+        if (exists) {
+          prompts.log.error(`Ad identifier already exists: ${id}`)
+          prompts.outro("Done")
+          return
+        }
+
+        const urlInput = await (async () => {
+          if (typeof args.url === "string") return args.url
+          const value = await prompts.text({
+            message: "URL (optional)",
+            validate: validateUrl,
+          })
+          if (prompts.isCancel(value)) throw new UI.CancelledError()
+          return value
+        })()
+
+        const urlError = validateUrl(urlInput)
+        if (urlError) {
+          prompts.log.error(urlError)
+          prompts.outro("Done")
+          return
+        }
+
+        const enabled = await (async () => {
+          if (args.disabled) return false
+          const value = await prompts.confirm({
+            message: "Enable this ad now?",
+            initialValue: true,
+          })
+          if (prompts.isCancel(value)) throw new UI.CancelledError()
+          return value
+        })()
+
+        const entry: AdsItem = {
+          id,
+          text,
+          url: normalizeUrl(urlInput) ?? undefined,
+          enabled,
+        }
+
+        const next: AdsConfig = {
+          ...ads,
+          enabled: ads.enabled ?? true,
+          items: items.concat(entry),
+        }
+
+        await saveAds(next)
+        prompts.log.success(`Ad created: ${id}`)
+        prompts.outro("Done")
+      },
+    })
+  },
+})
+
+export const AdsListCommand = cmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list ads",
+  async handler() {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Ads")
+
+        const ads = await loadAds()
+        const items = ads.items ?? []
+        if (items.length === 0) {
+          prompts.log.warn("No ads configured")
+          prompts.outro("Create ads with: nikcli ads create")
+          return
+        }
+
+        const globalEnabled = ads.enabled !== false
+        const globalLabel = globalEnabled ? "enabled" : "disabled"
+        prompts.log.info(`Ads are ${globalLabel}`)
+        if (ads.ratio !== undefined) {
+          prompts.log.info(`Ads ratio: ${ads.ratio}`)
+        }
+
+        for (const item of items) {
+          const itemEnabled = item.enabled !== false
+          const icon = itemEnabled ? "+" : "-"
+          const status = itemEnabled ? "enabled" : "disabled"
+          prompts.log.info(`${icon} ${item.id} ${UI.Style.TEXT_DIM}${status}`)
+          prompts.log.info(`    ${Locale.truncate(item.text, 96)}`)
+          if (item.url) {
+            prompts.log.info(`    ${UI.Style.TEXT_DIM}${item.url}`)
+          }
+        }
+
+        prompts.outro(`${items.length} ad(s)`)
+      },
+    })
+  },
+})
+
+export const AdsRemoveCommand = cmd({
+  command: "remove [id]",
+  aliases: ["rm"],
+  describe: "remove an ad",
+  builder: (yargs: Argv) =>
+    yargs.positional("id", {
+      describe: "ad identifier",
+      type: "string",
+    }),
+  async handler(args) {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Remove ad")
+
+        const ads = await loadAds()
+        const items = ads.items ?? []
+        if (items.length === 0) {
+          prompts.log.warn("No ads configured")
+          prompts.outro("Done")
+          return
+        }
+
+        const id = await selectId(items, args.id, "Select ad to remove")
+        const nextItems = items.filter((item) => item.id !== id)
+        if (nextItems.length === items.length) {
+          prompts.log.error(`Ad not found: ${id}`)
+          prompts.outro("Done")
+          return
+        }
+
+        const next: AdsConfig = {
+          ...ads,
+          items: nextItems,
+        }
+
+        await saveAds(next)
+        prompts.log.success(`Ad removed: ${id}`)
+        prompts.outro("Done")
+      },
+    })
+  },
+})
+
+export const AdsToggleCommand = cmd({
+  command: "toggle [id]",
+  describe: "toggle an ad on or off",
+  builder: (yargs: Argv) =>
+    yargs.positional("id", {
+      describe: "ad identifier",
+      type: "string",
+    }),
+  async handler(args) {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Toggle ad")
+
+        const ads = await loadAds()
+        const items = ads.items ?? []
+        if (items.length === 0) {
+          prompts.log.warn("No ads configured")
+          prompts.outro("Done")
+          return
+        }
+
+        const id = await selectId(items, args.id, "Select ad to toggle")
+        const found = items.some((item) => item.id === id)
+        if (!found) {
+          prompts.log.error(`Ad not found: ${id}`)
+          prompts.outro("Done")
+          return
+        }
+        const nextItems = items.map((item) => {
+          if (item.id !== id) return item
+          const enabled = item.enabled === false
+          return { ...item, enabled }
+        })
+
+        const next: AdsConfig = {
+          ...ads,
+          items: nextItems,
+        }
+
+        await saveAds(next)
+        const nextItem = nextItems.find((item) => item.id === id)
+        const status = nextItem?.enabled === false ? "disabled" : "enabled"
+        prompts.log.success(`Ad ${id} is now ${status}`)
+        prompts.outro("Done")
+      },
+    })
+  },
+})
+
+export const AdsEnableCommand = cmd({
+  command: "enable",
+  describe: "enable ads globally",
+  async handler() {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Enable ads")
+
+        const ads = await loadAds()
+        const next: AdsConfig = { ...ads, enabled: true }
+        await saveAds(next)
+
+        prompts.log.success("Ads enabled")
+        prompts.outro("Done")
+      },
+    })
+  },
+})
+
+export const AdsDisableCommand = cmd({
+  command: "disable",
+  describe: "disable ads globally",
+  async handler() {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Disable ads")
+
+        const ads = await loadAds()
+        const next: AdsConfig = { ...ads, enabled: false }
+        await saveAds(next)
+
+        prompts.log.success("Ads disabled")
+        prompts.outro("Done")
+      },
+    })
+  },
+})