nikcli 0.0.6

package/src/connectors/api/base.ts

@@ -0,0 +1,75 @@
+export abstract class BaseApiClient<AuthConfig extends Record<string, string>> {
+  protected abstract baseUrl: string
+
+  protected abstract getAuth(authConfig: AuthConfig): Record<string, string>
+
+  protected async request<T>(
+    path: string,
+    options: RequestInit & { query?: Record<string, string | number>; auth?: AuthConfig } = {},
+  ): Promise<T> {
+    let url = path.startsWith("http") ? path : `${this.baseUrl}${path}`
+
+    if (options.query) {
+      const params = new URLSearchParams()
+      for (const [key, value] of Object.entries(options.query)) {
+        params.append(key, String(value))
+      }
+      const separator = url.includes("?") ? "&" : "?"
+      url += separator + params.toString()
+    }
+
+    const { query, auth, ...fetchOptions } = options
+    const authHeaders = auth ? this.getAuth(auth) : {}
+
+    const response = await fetch(url, {
+      ...fetchOptions,
+      headers: {
+        ...authHeaders,
+        ...(fetchOptions.headers || {}),
+      },
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "")
+      throw new Error(
+        `${this.constructor.name} error: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`,
+      )
+    }
+
+    return response.json()
+  }
+
+  protected async get<T>(
+    path: string,
+    options?: Omit<RequestInit, "method"> & { query?: Record<string, string | number>; auth?: AuthConfig },
+  ): Promise<T> {
+    return this.request<T>(path, { ...options, method: "GET" })
+  }
+
+  protected async post<T>(
+    path: string,
+    body?: unknown,
+    options?: Omit<RequestInit, "method" | "body"> & { auth?: AuthConfig },
+  ): Promise<T> {
+    return this.request<T>(path, {
+      ...options,
+      method: "POST",
+      headers: {
+        ...(options?.headers || {}),
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    })
+  }
+}
+
+export class ApiError extends Error {
+  constructor(
+    public readonly service: string,
+    public readonly status: number,
+    public override readonly message: string,
+  ) {
+    super(`${service} error: ${status} ${message}`)
+    this.name = "ApiError"
+  }
+}

package/src/connectors/api/figma.ts

@@ -0,0 +1,103 @@
+import { ConnectorAuth } from "../auth"
+
+const FIGMA_API_BASE = "https://api.figma.com/v1"
+
+export namespace FigmaApi {
+  export async function getFile(token: string, fileKey: string): Promise<any> {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileKey}`, {
+      headers: { "X-Figma-Token": token },
+    })
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getFileComponents(token: string, fileKey: string): Promise<any> {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileKey}/components`, {
+      headers: { "X-Figma-Token": token },
+    })
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getFileStyles(token: string, fileKey: string): Promise<any> {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileKey}/styles`, {
+      headers: { "X-Figma-Token": token },
+    })
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getComments(token: string, fileKey: string): Promise<any> {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileKey}/comments`, {
+      headers: { "X-Figma-Token": token },
+    })
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getImage(token: string, fileKey: string, nodeIds: string[], scale: number = 2): Promise<any> {
+    const response = await fetch(
+      `${FIGMA_API_BASE}/images/${fileKey}?ids=${nodeIds.join(",")}&scale=${scale}&format=png`,
+      {
+        headers: { "X-Figma-Token": token },
+      },
+    )
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getTeamProjects(token: string, teamId: string): Promise<any> {
+    const response = await fetch(`${FIGMA_API_BASE}/teams/${teamId}/projects`, {
+      headers: { "X-Figma-Token": token },
+    })
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getProjectFiles(token: string, projectId: string): Promise<any> {
+    const response = await fetch(`${FIGMA_API_BASE}/projects/${projectId}/files`, {
+      headers: { "X-Figma-Token": token },
+    })
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getMe(token: string): Promise<any> {
+    const response = await fetch(`${FIGMA_API_BASE}/me`, {
+      headers: { "X-Figma-Token": token },
+    })
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getNode(token: string, fileKey: string, nodeId: string): Promise<any> {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileKey}/nodes?ids=${nodeId}`, {
+      headers: { "X-Figma-Token": token },
+    })
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+}
+
+export async function getToken(name: string): Promise<string | null> {
+  const auth = await ConnectorAuth.get(name)
+  return auth?.token ?? null
+}

package/src/connectors/api/github.ts

@@ -0,0 +1,247 @@
+import { ConnectorAuth } from "../auth"
+
+const GITHUB_API_BASE = "https://api.github.com"
+
+export namespace GithubApi {
+  export async function getRepo(token: string, owner: string, repo: string): Promise<any> {
+    const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getRepoContent(
+    token: string,
+    owner: string,
+    repo: string,
+    path: string,
+    ref?: string,
+  ): Promise<any> {
+    const url = ref
+      ? `${GITHUB_API_BASE}/repos/${owner}/${repo}/contents/${path}?ref=${ref}`
+      : `${GITHUB_API_BASE}/repos/${owner}/${repo}/contents/${path}`
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function createIssue(
+    token: string,
+    owner: string,
+    repo: string,
+    title: string,
+    body?: string,
+  ): Promise<any> {
+    const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/issues`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ title, body }),
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`GitHub API error: ${response.status} - ${error}`)
+    }
+    return response.json()
+  }
+
+  export async function getIssue(token: string, owner: string, repo: string, issueNumber: number): Promise<any> {
+    const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/issues/${issueNumber}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function listIssues(
+    token: string,
+    owner: string,
+    repo: string,
+    state: "open" | "closed" | "all" = "open",
+  ): Promise<any> {
+    const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/issues?state=${state}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function searchCode(token: string, query: string, sort?: string, order?: "asc" | "desc"): Promise<any> {
+    let url = `${GITHUB_API_BASE}/search/code?q=${encodeURIComponent(query)}`
+    if (sort) url += `&sort=${sort}&order=${order}`
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function searchRepos(
+    token: string,
+    query: string,
+    sort?: "stars" | "updated" | "help-wanted-issues",
+  ): Promise<any> {
+    let url = `${GITHUB_API_BASE}/search/repositories?q=${encodeURIComponent(query)}`
+    if (sort) url += `&sort=${sort}`
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getUser(token: string): Promise<any> {
+    const response = await fetch(`${GITHUB_API_BASE}/user`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function listRepos(
+    token: string,
+    type: "all" | "owner" | "member" = "owner",
+    sort?: "updated" | "pushed" | "full_name",
+  ): Promise<any> {
+    let url = `${GITHUB_API_BASE}/user/repos?type=${type}`
+    if (sort) url += `&sort=${sort}`
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function listBranches(token: string, owner: string, repo: string): Promise<any> {
+    const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/branches?per_page=100`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function findPullRequestByHead(
+    token: string,
+    owner: string,
+    repo: string,
+    head: string,
+    state: "open" | "closed" | "all" = "open",
+  ): Promise<any | undefined> {
+    const response = await fetch(
+      `${GITHUB_API_BASE}/repos/${owner}/${repo}/pulls?head=${encodeURIComponent(head)}&state=${state}&per_page=1`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: "application/vnd.github.v3+json",
+        },
+      },
+    )
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    const pulls = (await response.json()) as any[]
+    return pulls[0]
+  }
+
+  export async function createPullRequest(
+    token: string,
+    owner: string,
+    repo: string,
+    title: string,
+    head: string,
+    base: string,
+    body?: string,
+  ): Promise<any> {
+    const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/pulls`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ title, head, base, body }),
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`GitHub API error: ${response.status} - ${error}`)
+    }
+    return response.json()
+  }
+
+  export async function getPullRequest(token: string, owner: string, repo: string, pullNumber: number): Promise<any> {
+    const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/pulls/${pullNumber}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getFileContent(token: string, owner: string, repo: string, path: string): Promise<string> {
+    const content = await getRepoContent(token, owner, repo, path)
+    if (content.encoding === "base64" && content.content) {
+      return Buffer.from(content.content, "base64").toString("utf-8")
+    }
+    throw new Error("Unable to decode file content")
+  }
+}
+
+export async function getToken(name: string): Promise<string | null> {
+  const auth = await ConnectorAuth.get(name)
+  return auth?.token ?? null
+}

package/src/connectors/api/lovable.ts

@@ -0,0 +1,126 @@
+import { ConnectorAuth } from "../auth"
+
+const LOVABLE_API_BASE = "https://api.lovable.dev/v1"
+
+export namespace LovableApi {
+  export async function getProjects(token: string): Promise<any> {
+    const response = await fetch(`${LOVABLE_API_BASE}/projects`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`Lovable API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getProject(token: string, projectId: string): Promise<any> {
+    const response = await fetch(`${LOVABLE_API_BASE}/projects/${projectId}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`Lovable API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getChats(token: string, projectId: string): Promise<any> {
+    const response = await fetch(`${LOVABLE_API_BASE}/projects/${projectId}/chats`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`Lovable API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getChatMessages(token: string, projectId: string, chatId: string): Promise<any> {
+    const response = await fetch(`${LOVABLE_API_BASE}/projects/${projectId}/chats/${chatId}/messages`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`Lovable API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function sendMessage(token: string, projectId: string, message: string, chatId?: string): Promise<any> {
+    const response = await fetch(`${LOVABLE_API_BASE}/projects/${projectId}/chats`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ message, chatId }),
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Lovable API error: ${response.status} - ${error}`)
+    }
+    return response.json()
+  }
+
+  export async function getProjectFiles(token: string, projectId: string): Promise<any> {
+    const response = await fetch(`${LOVABLE_API_BASE}/projects/${projectId}/files`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    })
+    if (!response.ok) {
+      throw new Error(`Lovable API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function getFileContent(token: string, projectId: string, filePath: string): Promise<any> {
+    const response = await fetch(
+      `${LOVABLE_API_BASE}/projects/${projectId}/files/${encodeURIComponent(filePath)}/content`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: "application/json",
+        },
+      },
+    )
+    if (!response.ok) {
+      throw new Error(`Lovable API error: ${response.status} ${response.statusText}`)
+    }
+    return response.json()
+  }
+
+  export async function runPrompt(token: string, projectId: string, prompt: string): Promise<any> {
+    const response = await fetch(`${LOVABLE_API_BASE}/projects/${projectId}/prompts`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ prompt }),
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Lovable API error: ${response.status} - ${error}`)
+    }
+    return response.json()
+  }
+}
+
+export async function getToken(name: string): Promise<string | null> {
+  const auth = await ConnectorAuth.get(name)
+  if (auth?.token) return auth.token
+  return auth?.apiKey ?? null
+}

package/src/connectors/api/slack.ts

@@ -0,0 +1,137 @@
+import { ConnectorAuth } from "../auth"
+
+const SLACK_API_BASE = "https://slack.com/api"
+
+export namespace SlackApi {
+  export async function sendMessage(botToken: string, channel: string, text: string, blocks?: any[]): Promise<any> {
+    const body: any = { channel, text }
+    if (blocks) body.blocks = blocks
+
+    const response = await fetch(`${SLACK_API_BASE}/chat.postMessage`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${botToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    })
+    const result = await response.json()
+    if (!result.ok) {
+      throw new Error(`Slack API error: ${result.error}`)
+    }
+    return result
+  }
+
+  export async function getConversationInfo(botToken: string, channel: string): Promise<any> {
+    const response = await fetch(`${SLACK_API_BASE}/conversations.info?channel=${channel}`, {
+      headers: { Authorization: `Bearer ${botToken}` },
+    })
+    const result = await response.json()
+    if (!result.ok) {
+      throw new Error(`Slack API error: ${result.error}`)
+    }
+    return result
+  }
+
+  export async function listConversations(botToken: string, types?: string): Promise<any> {
+    const url = types ? `${SLACK_API_BASE}/conversations.list?types=${types}` : `${SLACK_API_BASE}/conversations.list`
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${botToken}` },
+    })
+    const result = await response.json()
+    if (!result.ok) {
+      throw new Error(`Slack API error: ${result.error}`)
+    }
+    return result
+  }
+
+  export async function searchMessages(botToken: string, query: string, count: number = 20): Promise<any> {
+    const response = await fetch(
+      `${SLACK_API_BASE}/search.messages?query=${encodeURIComponent(query)}&count=${count}`,
+      {
+        headers: { Authorization: `Bearer ${botToken}` },
+      },
+    )
+    const result = await response.json()
+    if (!result.ok) {
+      throw new Error(`Slack API error: ${result.error}`)
+    }
+    return result
+  }
+
+  export async function getPermalink(botToken: string, channel: string, timestamp: string): Promise<any> {
+    const response = await fetch(`${SLACK_API_BASE}/chat.getPermalink?channel=${channel}&message_ts=${timestamp}`, {
+      headers: { Authorization: `Bearer ${botToken}` },
+    })
+    const result = await response.json()
+    if (!result.ok) {
+      throw new Error(`Slack API error: ${result.error}`)
+    }
+    return result
+  }
+
+  export async function replyToMessage(
+    botToken: string,
+    channel: string,
+    threadTs: string,
+    text: string,
+  ): Promise<any> {
+    const response = await fetch(`${SLACK_API_BASE}/chat.postMessage`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${botToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ channel, text, thread_ts: threadTs }),
+    })
+    const result = await response.json()
+    if (!result.ok) {
+      throw new Error(`Slack API error: ${result.error}`)
+    }
+    return result
+  }
+
+  export async function uploadFile(
+    botToken: string,
+    channels: string,
+    fileData: Uint8Array,
+    filename: string,
+  ): Promise<any> {
+    const formData = new FormData()
+    formData.append("channels", channels)
+    formData.append("file", new Blob([fileData.buffer as ArrayBuffer]), filename)
+    formData.append("filename", filename)
+
+    const response = await fetch(`${SLACK_API_BASE}/files.upload`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${botToken}` },
+      body: formData,
+    })
+    const result = await response.json()
+    if (!result.ok) {
+      throw new Error(`Slack API error: ${result.error}`)
+    }
+    return result
+  }
+
+  export async function listUsers(botToken: string): Promise<any> {
+    const response = await fetch(`${SLACK_API_BASE}/users.list`, {
+      headers: { Authorization: `Bearer ${botToken}` },
+    })
+    const result = await response.json()
+    if (!result.ok) {
+      throw new Error(`Slack API error: ${result.error}`)
+    }
+    return result
+  }
+}
+
+export async function getBotToken(name: string): Promise<string | null> {
+  const auth = await ConnectorAuth.get(name)
+  return auth?.botToken ?? null
+}
+
+export async function getTeamId(name: string): Promise<string | null> {
+  const auth = await ConnectorAuth.get(name)
+  return auth?.teamId ?? null
+}