nikcli 0.0.6

package/src/connectors/registry.ts

@@ -0,0 +1,358 @@
+import { dynamicTool, type Tool, jsonSchema } from "ai"
+import { Config } from "../config/config"
+import { resolveCredential } from "./credentials"
+import { FigmaApi } from "./api/figma"
+import { SlackApi } from "./api/slack"
+import { GithubApi } from "./api/github"
+import { LovableApi } from "./api/lovable"
+
+export interface OperationArg {
+  name: string
+  description: string
+  required?: boolean
+  type?: "string" | "number" | "boolean"
+  enum?: string[]
+}
+
+export interface OperationSpec {
+  name: string
+  description: string
+  args: OperationArg[]
+  execute: (credential: string, args: Record<string, any>) => Promise<any>
+}
+
+export interface ConnectorSpec {
+  type: string
+  credentialType: "token" | "botToken" | "apiKey"
+  operations: OperationSpec[]
+  healthCheck: (credential: string) => Promise<void>
+}
+
+const FIGMA_OPERATIONS: OperationSpec[] = [
+  {
+    name: "figma_get_file",
+    description: "Get the contents of a Figma file including all pages and frames",
+    args: [{ name: "fileKey", description: "The Figma file key (found in Figma URL after /file/)", required: true }],
+    execute: (cred, args) => FigmaApi.getFile(cred, args.fileKey),
+  },
+  {
+    name: "figma_get_components",
+    description: "Get all components from a Figma file",
+    args: [{ name: "fileKey", description: "The Figma file key", required: true }],
+    execute: (cred, args) => FigmaApi.getFileComponents(cred, args.fileKey),
+  },
+  {
+    name: "figma_get_styles",
+    description: "Get all styles from a Figma file",
+    args: [{ name: "fileKey", description: "The Figma file key", required: true }],
+    execute: (cred, args) => FigmaApi.getFileStyles(cred, args.fileKey),
+  },
+  {
+    name: "figma_get_comments",
+    description: "Get all comments from a Figma file",
+    args: [{ name: "fileKey", description: "The Figma file key", required: true }],
+    execute: (cred, args) => FigmaApi.getComments(cred, args.fileKey),
+  },
+]
+
+const SLACK_OPERATIONS: OperationSpec[] = [
+  {
+    name: "slack_list_channels",
+    description: "List all channels in a Slack workspace",
+    args: [
+      {
+        name: "types",
+        description: "Comma-separated channel types: public_channel, private_channel, mpim, im",
+        type: "string",
+      },
+    ],
+    execute: (cred, args) => SlackApi.listConversations(cred, args.types),
+  },
+  {
+    name: "slack_send_message",
+    description: "Send a message to a Slack channel",
+    args: [
+      {
+        name: "channel",
+        description: "The Slack channel ID (e.g., C01234567) or name (e.g., general)",
+        required: true,
+      },
+      { name: "text", description: "The message text to send", required: true },
+    ],
+    execute: (cred, args) => SlackApi.sendMessage(cred, args.channel, args.text),
+  },
+  {
+    name: "slack_search_messages",
+    description: "Search for messages in Slack",
+    args: [
+      { name: "query", description: "The search query", required: true },
+      { name: "count", description: "Maximum number of results (default 20)", type: "number" },
+    ],
+    execute: (cred, args) => SlackApi.searchMessages(cred, args.query, args.count),
+  },
+  {
+    name: "slack_get_channel_info",
+    description: "Get information about a Slack channel",
+    args: [{ name: "channel", description: "The Slack channel ID", required: true }],
+    execute: (cred, args) => SlackApi.getConversationInfo(cred, args.channel),
+  },
+  {
+    name: "slack_reply_to_thread",
+    description: "Reply to a message thread in Slack",
+    args: [
+      { name: "channel", description: "The Slack channel ID", required: true },
+      { name: "threadTs", description: "The thread timestamp (ts) from the original message", required: true },
+      { name: "text", description: "The reply text", required: true },
+    ],
+    execute: (cred, args) => SlackApi.replyToMessage(cred, args.channel, args.threadTs, args.text),
+  },
+]
+
+const GITHUB_OPERATIONS: OperationSpec[] = [
+  {
+    name: "github_get_repo",
+    description: "Get information about a GitHub repository",
+    args: [
+      { name: "owner", description: "Repository owner (username or organization)", required: true },
+      { name: "repo", description: "Repository name", required: true },
+    ],
+    execute: (cred, args) => GithubApi.getRepo(cred, args.owner, args.repo),
+  },
+  {
+    name: "github_get_file",
+    description: "Get the contents of a file from a GitHub repository",
+    args: [
+      { name: "owner", description: "Repository owner", required: true },
+      { name: "repo", description: "Repository name", required: true },
+      { name: "path", description: "Path to the file in the repository", required: true },
+      { name: "ref", description: "Branch, tag, or commit (optional)", type: "string" },
+    ],
+    execute: (cred, args) => GithubApi.getFileContent(cred, args.owner, args.repo, args.path),
+  },
+  {
+    name: "github_create_issue",
+    description: "Create a new issue in a GitHub repository",
+    args: [
+      { name: "owner", description: "Repository owner", required: true },
+      { name: "repo", description: "Repository name", required: true },
+      { name: "title", description: "Issue title", required: true },
+      { name: "body", description: "Issue body (optional)", type: "string" },
+    ],
+    execute: (cred, args) => GithubApi.createIssue(cred, args.owner, args.repo, args.title, args.body),
+  },
+  {
+    name: "github_list_issues",
+    description: "List issues in a GitHub repository",
+    args: [
+      { name: "owner", description: "Repository owner", required: true },
+      { name: "repo", description: "Repository name", required: true },
+      { name: "state", description: "Issue state (default: open)", enum: ["open", "closed", "all"], type: "string" },
+    ],
+    execute: (cred, args) => GithubApi.listIssues(cred, args.owner, args.repo, args.state),
+  },
+  {
+    name: "github_search_code",
+    description: "Search for code in GitHub",
+    args: [
+      { name: "query", description: "Search query (supports GitHub code search syntax)", required: true },
+      { name: "sort", description: "Sort by", enum: ["indexed"], type: "string" },
+      { name: "order", description: "Order direction", enum: ["asc", "desc"], type: "string" },
+    ],
+    execute: (cred, args) => GithubApi.searchCode(cred, args.query, args.sort, args.order),
+  },
+  {
+    name: "github_list_repos",
+    description: "List repositories for the authenticated user",
+    args: [
+      {
+        name: "type",
+        description: "Repository type (default: owner)",
+        enum: ["all", "owner", "member"],
+        type: "string",
+      },
+      { name: "sort", description: "Sort by", enum: ["updated", "pushed", "full_name"], type: "string" },
+    ],
+    execute: (cred, args) => GithubApi.listRepos(cred, args.type, args.sort),
+  },
+]
+
+const LOVABLE_OPERATIONS: OperationSpec[] = [
+  {
+    name: "lovable_get_projects",
+    description: "Get all Lovable projects",
+    args: [],
+    execute: (cred) => LovableApi.getProjects(cred),
+  },
+  {
+    name: "lovable_get_project",
+    description: "Get information about a Lovable project",
+    args: [{ name: "projectId", description: "The Lovable project ID", required: true }],
+    execute: (cred, args) => LovableApi.getProject(cred, args.projectId),
+  },
+  {
+    name: "lovable_get_chats",
+    description: "Get all chats for a Lovable project",
+    args: [{ name: "projectId", description: "The Lovable project ID", required: true }],
+    execute: (cred, args) => LovableApi.getChats(cred, args.projectId),
+  },
+  {
+    name: "lovable_send_message",
+    description: "Send a message to a Lovable project",
+    args: [
+      { name: "projectId", description: "The Lovable project ID", required: true },
+      { name: "message", description: "The message to send", required: true },
+      { name: "chatId", description: "Existing chat ID (optional, creates new chat if not provided)", type: "string" },
+    ],
+    execute: (cred, args) => LovableApi.sendMessage(cred, args.projectId, args.message, args.chatId),
+  },
+  {
+    name: "lovable_get_project_files",
+    description: "Get all files in a Lovable project",
+    args: [{ name: "projectId", description: "The Lovable project ID", required: true }],
+    execute: (cred, args) => LovableApi.getProjectFiles(cred, args.projectId),
+  },
+  {
+    name: "lovable_run_prompt",
+    description: "Run a prompt in a Lovable project",
+    args: [
+      { name: "projectId", description: "The Lovable project ID", required: true },
+      { name: "prompt", description: "The prompt to run", required: true },
+    ],
+    execute: (cred, args) => LovableApi.runPrompt(cred, args.projectId, args.prompt),
+  },
+]
+
+const CONNECTOR_SPECS: Record<string, ConnectorSpec> = {
+  figma: {
+    type: "figma",
+    credentialType: "token",
+    operations: FIGMA_OPERATIONS,
+    healthCheck: (cred) => FigmaApi.getMe(cred),
+  },
+  slack: {
+    type: "slack",
+    credentialType: "botToken",
+    operations: SLACK_OPERATIONS,
+    healthCheck: (cred) => SlackApi.listUsers(cred),
+  },
+  github: {
+    type: "github",
+    credentialType: "token",
+    operations: GITHUB_OPERATIONS,
+    healthCheck: (cred) => GithubApi.getUser(cred),
+  },
+  lovable: {
+    type: "lovable",
+    credentialType: "token",
+    operations: LOVABLE_OPERATIONS,
+    healthCheck: (cred) => LovableApi.getProjects(cred),
+  },
+  discord: {
+    type: "discord",
+    credentialType: "botToken",
+    operations: [],
+    healthCheck: async () => {},
+  },
+  teams: {
+    type: "teams",
+    credentialType: "botToken",
+    operations: [],
+    healthCheck: async () => {},
+  },
+  gchat: {
+    type: "gchat",
+    credentialType: "botToken",
+    operations: [],
+    healthCheck: async () => {},
+  },
+  linear: {
+    type: "linear",
+    credentialType: "botToken",
+    operations: [],
+    healthCheck: async () => {},
+  },
+}
+
+export function getConnectorSpec(type: string): ConnectorSpec | undefined {
+  return CONNECTOR_SPECS[type]
+}
+
+export function listConnectorTypes(): string[] {
+  return Object.keys(CONNECTOR_SPECS)
+}
+
+export async function createTools(name: string, connector: Config.Connector): Promise<Record<string, Tool>> {
+  const spec = CONNECTOR_SPECS[connector.type]
+  if (!spec) return {}
+
+  const credential = await resolveCredential(name, connector)
+  if (!credential) return {}
+
+  const tools: Record<string, Tool> = {}
+
+  for (const operation of spec.operations) {
+    const toolName = `${name}_${operation.name}`
+    tools[toolName] = dynamicTool({
+      description: operation.description,
+      inputSchema: jsonSchema({
+        type: "object",
+        properties: Object.fromEntries(
+          operation.args.map((arg) => [
+            arg.name,
+            {
+              type: arg.type ?? "string",
+              description: arg.description,
+              ...(arg.enum && { enum: arg.enum }),
+            },
+          ]),
+        ),
+        required: operation.args.filter((arg) => arg.required).map((arg) => arg.name),
+        additionalProperties: false,
+      }),
+      execute: async (args: unknown) => {
+        const typedArgs = args as Record<string, any>
+        const result = await operation.execute(credential, typedArgs)
+        return typeof result === "string" ? result : JSON.stringify(result, null, 2)
+      },
+    }) as Tool
+  }
+
+  return tools
+}
+
+export async function executeOperation(
+  name: string,
+  connector: Config.Connector,
+  operationName: string,
+  args: Record<string, any>,
+): Promise<any> {
+  const spec = CONNECTOR_SPECS[connector.type]
+  if (!spec) throw new Error(`Unknown connector type: ${connector.type}`)
+
+  const credential = await resolveCredential(name, connector)
+  if (!credential) throw new Error(`No credential for connector "${name}"`)
+
+  const operation = spec.operations.find((op) => op.name === operationName)
+  if (!operation) throw new Error(`Unknown operation: ${operationName}`)
+
+  return operation.execute(credential, args)
+}
+
+export function getHealthCheck(type: string): ((credential: string) => Promise<void>) | undefined {
+  return CONNECTOR_SPECS[type]?.healthCheck
+}
+
+export function getOperationSpec(type: string, operationName: string): OperationSpec | undefined {
+  return CONNECTOR_SPECS[type]?.operations.find((op) => op.name === operationName)
+}
+
+export function getPrompts(type: string): Array<{ name: string; description: string; args: OperationArg[] }> {
+  const spec = CONNECTOR_SPECS[type]
+  if (!spec) return []
+
+  return spec.operations.map((op) => ({
+    name: op.name,
+    description: op.description,
+    args: op.args,
+  }))
+}

package/src/docs/context.ts

@@ -0,0 +1,120 @@
+import path from "path"
+import { mkdir } from "fs/promises"
+import { Global } from "@/global"
+import { getAllDocs, type DocEntry } from "./library"
+
+type DocsContext = {
+  ids: string[]
+  updatedAt: number
+}
+
+const DIR = path.join(Global.Path.data, "docs")
+const FILE = path.join(DIR, "context.json")
+const MAX_SUMMARY_CHARS = 4000
+const MAX_FULL_CHARS = 20000
+
+async function ensureDir() {
+  await mkdir(DIR, { recursive: true })
+}
+
+async function readContext(): Promise<DocsContext> {
+  const file = Bun.file(FILE)
+  const exists = await file.exists()
+  if (!exists) return { ids: [], updatedAt: Date.now() }
+  const data = await file.json().catch(() => null)
+  if (!data || !Array.isArray(data.ids)) return { ids: [], updatedAt: Date.now() }
+  return {
+    ids: data.ids,
+    updatedAt: typeof data.updatedAt === "number" ? data.updatedAt : Date.now(),
+  }
+}
+
+async function writeContext(context: DocsContext): Promise<void> {
+  await ensureDir()
+  await Bun.write(FILE, JSON.stringify(context, null, 2))
+}
+
+function unique(ids: string[]): string[] {
+  return Array.from(new Set(ids))
+}
+
+export async function loadDocs(ids: string[]): Promise<{ loaded: DocEntry[]; missing: string[] }> {
+  const ctx = await readContext()
+  const all = await getAllDocs()
+  const valid = all.filter((entry) => ids.some((id) => matches(entry, id)))
+  const foundIds = valid.map((entry) => entry.id)
+  const missing = ids.filter((id) => !all.some((entry) => matches(entry, id)))
+  const next = unique([...ctx.ids, ...foundIds])
+  await writeContext({ ids: next, updatedAt: Date.now() })
+  return { loaded: valid, missing }
+}
+
+export async function unloadDocs(ids?: string[]): Promise<{ removed: string[] }> {
+  const ctx = await readContext()
+  if (!ids || ids.length === 0) {
+    await writeContext({ ids: [], updatedAt: Date.now() })
+    return { removed: ctx.ids }
+  }
+  const all = await getAllDocs()
+  const loaded = ctx.ids
+    .map((id) => all.find((entry) => entry.id === id))
+    .filter((entry): entry is DocEntry => Boolean(entry))
+  const toRemove = loaded.filter((entry) => ids.some((id) => matches(entry, id))).map((entry) => entry.id)
+  const removed = ctx.ids.filter((id) => toRemove.includes(id))
+  const next = ctx.ids.filter((id) => !toRemove.includes(id))
+  await writeContext({ ids: next, updatedAt: Date.now() })
+  return { removed }
+}
+
+export async function getLoadedDocs(): Promise<DocEntry[]> {
+  const ctx = await readContext()
+  if (ctx.ids.length === 0) return []
+  const docs = await getAllDocs()
+  const sorted = ctx.ids
+    .map((id) => docs.find((entry) => entry.id === id))
+    .filter((entry): entry is DocEntry => Boolean(entry))
+  return sorted
+}
+
+function summaryLine(entry: DocEntry): string {
+  const tags = entry.tags.length > 0 ? ` tags: ${entry.tags.join(", ")}` : ""
+  return `- ${entry.title} (${entry.category})${tags}`
+}
+
+function matches(entry: DocEntry, key: string): boolean {
+  const lower = key.toLowerCase()
+  if (entry.id === key) return true
+  if (entry.url.toLowerCase().includes(lower)) return true
+  if (entry.title.toLowerCase().includes(lower)) return true
+  if (entry.tags.some((tag) => tag.toLowerCase().includes(lower))) return true
+  return false
+}
+
+export async function getContextSummary(): Promise<string> {
+  const docs = await getLoadedDocs()
+  if (docs.length === 0) return "No documentation loaded."
+  const lines = docs.map(summaryLine)
+  const summary = `Documentation context (${docs.length} docs)\n` + lines.join("\n")
+  if (summary.length <= MAX_SUMMARY_CHARS) return summary
+  return summary.slice(0, MAX_SUMMARY_CHARS) + "\n[summary truncated]"
+}
+
+export async function getFullContext(): Promise<string> {
+  const docs = await getLoadedDocs()
+  if (docs.length === 0) return ""
+  const chunks = docs.map((entry) => {
+    return [
+      `## ${entry.title}`,
+      `Category: ${entry.category}`,
+      entry.tags.length > 0 ? `Tags: ${entry.tags.join(", ")}` : "",
+      entry.url ? `Source: ${entry.url}` : "",
+      "",
+      entry.content,
+    ]
+      .filter(Boolean)
+      .join("\n")
+  })
+  const content = `# DOCUMENTATION CONTEXT\n\n` + chunks.join("\n\n---\n\n")
+  if (content.length <= MAX_FULL_CHARS) return content
+  return content.slice(0, MAX_FULL_CHARS) + "\n[context truncated]"
+}

package/src/docs/library.ts

@@ -0,0 +1,189 @@
+import path from "path"
+import { mkdir } from "fs/promises"
+import { randomUUID } from "crypto"
+import TurndownService from "turndown"
+import { Global } from "@/global"
+
+export type DocEntry = {
+  id: string
+  url: string
+  title: string
+  content: string
+  category: string
+  tags: string[]
+  addedAt: number
+}
+
+export type DocSearchResult = {
+  entry: DocEntry
+  score: number
+  snippet: string
+  terms: string[]
+}
+
+const DIR = path.join(Global.Path.data, "docs")
+const LIB = path.join(DIR, "library.json")
+const MAX_CONTENT = 60000
+const MIN_CONTENT = 200
+
+const turndown = new TurndownService({
+  codeBlockStyle: "fenced",
+  headingStyle: "atx",
+})
+
+async function ensureDir() {
+  await mkdir(DIR, { recursive: true })
+}
+
+async function readAll(): Promise<DocEntry[]> {
+  const file = Bun.file(LIB)
+  const exists = await file.exists()
+  if (!exists) return []
+  const data = await file.json()
+  const list = Array.isArray(data) ? data : []
+  return list as DocEntry[]
+}
+
+async function writeAll(list: DocEntry[]): Promise<void> {
+  await ensureDir()
+  await Bun.write(LIB, JSON.stringify(list, null, 2))
+}
+
+function cleanHtml(html: string): string {
+  const noScript = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, " ")
+  const noStyle = noScript.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, " ")
+  return noStyle
+}
+
+function toText(html: string): string {
+  const cleaned = cleanHtml(html)
+  const text = turndown.turndown(cleaned)
+  return text.replace(/\n{3,}/g, "\n\n").trim()
+}
+
+function getTitle(html: string, url: string): string {
+  const match = html.match(/<title[^>]*>([^<]+)<\/title>/i)
+  if (match?.[1]) return match[1].trim().slice(0, 120)
+  return url
+}
+
+function normalize(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+}
+
+function terms(text: string): string[] {
+  const list = normalize(text).split(" ").filter(Boolean)
+  if (list.length === 0) return []
+  return Array.from(new Set(list))
+}
+
+function score(entry: DocEntry, query: string): { score: number; terms: string[] } {
+  const items = terms(query)
+  if (items.length === 0) return { score: 0, terms: [] }
+  const title = normalize(entry.title)
+  const body = normalize(entry.content)
+  const tags = entry.tags.map((tag) => normalize(tag)).join(" ")
+  const base = items.reduce((sum, item) => {
+    const inTitle = title.includes(item) ? 2 : 0
+    const inBody = body.includes(item) ? 1 : 0
+    const inTags = tags.includes(item) ? 1 : 0
+    return sum + inTitle + inBody + inTags
+  }, 0)
+  const value = base / items.length
+  return { score: value, terms: items }
+}
+
+function snippet(entry: DocEntry, query: string): string {
+  const items = terms(query)
+  const text = entry.content
+  const lower = text.toLowerCase()
+  const idx = items
+    .map((item) => lower.indexOf(item))
+    .filter((val) => val >= 0)
+    .sort((a, b) => a - b)[0]
+  if (idx === undefined) return text.slice(0, 200)
+  const start = Math.max(0, idx - 80)
+  const end = Math.min(text.length, idx + 140)
+  return text.slice(start, end).replace(/\s+/g, " ").trim()
+}
+
+function match(entry: DocEntry, key: string): boolean {
+  const lower = key.toLowerCase()
+  if (entry.id === key) return true
+  if (entry.url.toLowerCase().includes(lower)) return true
+  if (entry.title.toLowerCase().includes(lower)) return true
+  if (entry.tags.some((tag) => tag.toLowerCase().includes(lower))) return true
+  return false
+}
+
+export async function addDoc(input: { url: string; category?: string; tags?: string[] }): Promise<DocEntry> {
+  const res = await fetch(input.url)
+  if (!res.ok) {
+    throw new Error(`Docs fetch failed: ${res.status} ${res.statusText}`)
+  }
+  const html = await res.text()
+  const title = getTitle(html, input.url)
+  const text = toText(html)
+  if (text.length < MIN_CONTENT) {
+    throw new Error("Docs content too short to index")
+  }
+
+  const entry: DocEntry = {
+    id: randomUUID(),
+    url: input.url,
+    title,
+    content: text.slice(0, MAX_CONTENT),
+    category: input.category || "general",
+    tags: (input.tags ?? []).filter(Boolean),
+    addedAt: Date.now(),
+  }
+
+  await ensureDir()
+  const list = await readAll()
+  const next = [entry, ...list]
+  await writeAll(next)
+  return entry
+}
+
+export async function listDocs(category?: string): Promise<DocEntry[]> {
+  const list = await readAll()
+  if (!category) return list
+  return list.filter((item) => item.category === category)
+}
+
+export async function getAllDocs(): Promise<DocEntry[]> {
+  return readAll()
+}
+
+export async function getDoc(key: string): Promise<DocEntry | undefined> {
+  const list = await readAll()
+  return list.find((entry) => match(entry, key))
+}
+
+export async function getDocs(keys: string[]): Promise<DocEntry[]> {
+  const list = await readAll()
+  return list.filter((entry) => keys.some((key) => match(entry, key)))
+}
+
+export async function searchDocs(query: string, category?: string, limit = 5): Promise<DocSearchResult[]> {
+  const list = await readAll()
+  const items = category ? list.filter((item) => item.category === category) : list
+  const scored = items
+    .map((entry) => {
+      const result = score(entry, query)
+      return {
+        entry,
+        score: result.score,
+        snippet: snippet(entry, query),
+        terms: result.terms,
+      }
+    })
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+  return scored
+}

package/src/env/index.ts

@@ -0,0 +1,26 @@
+import { Instance } from "../project/instance"
+
+export namespace Env {
+  const state = Instance.state(() => {
+    return process.env as Record<string, string | undefined>
+  })
+
+  export function get(key: string) {
+    const env = state()
+    return env[key]
+  }
+
+  export function all() {
+    return state()
+  }
+
+  export function set(key: string, value: string) {
+    const env = state()
+    env[key] = value
+  }
+
+  export function remove(key: string) {
+    const env = state()
+    delete env[key]
+  }
+}