agentikit 0.0.13 → 0.0.14

package/src/registry-search.ts

@@ -1,335 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import { fetchWithTimeout } from "./common"
-import type { RegistrySearchHit, RegistrySearchResponse } from "./registry-types"
-
-// ── Constants ───────────────────────────────────────────────────────────────
-
-/** Default registry index URL. Override via config or AKM_REGISTRY_URL env var. */
-const DEFAULT_REGISTRY_URL =
-  "https://raw.githubusercontent.com/itlackey/agentikit-registry/main/index.json"
-
-/** Cache TTL in milliseconds (1 hour). */
-const CACHE_TTL_MS = 60 * 60 * 1000
-
-/** Maximum age before cache is considered stale but still usable as fallback (7 days). */
-const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export interface RegistryIndex {
-  version: number
-  updatedAt: string
-  kits: RegistryKitEntry[]
-}
-
-export interface RegistryKitEntry {
-  id: string
-  name: string
-  description?: string
-  ref: string
-  source: "npm" | "github" | "git"
-  homepage?: string
-  tags?: string[]
-  assetTypes?: string[]
-  author?: string
-  license?: string
-  latestVersion?: string
-  /** Whether this entry was manually reviewed and approved */
-  curated?: boolean
-}
-
-export interface RegistrySearchOptions {
-  limit?: number
-  /** Override registry URL(s). Accepts a single URL or an array. */
-  registryUrls?: string | string[]
-}
-
-// ── Public API ──────────────────────────────────────────────────────────────
-
-export async function searchRegistry(
-  query: string,
-  options?: RegistrySearchOptions,
-): Promise<RegistrySearchResponse> {
-  const trimmed = query.trim()
-  if (!trimmed) {
-    return { query: "", hits: [], warnings: [] }
-  }
-
-  const limit = clampLimit(options?.limit)
-  const urls = resolveRegistryUrls(options?.registryUrls)
-  const warnings: string[] = []
-
-  // Load index from all configured registries, merge kits
-  const allKits: RegistryKitEntry[] = []
-  for (const url of urls) {
-    try {
-      const index = await loadIndex(url)
-      if (index) {
-        allKits.push(...index.kits)
-      }
-    } catch (err) {
-      warnings.push(`Registry ${url}: ${toErrorMessage(err)}`)
-    }
-  }
-
-  // Score and rank
-  const hits = scoreKits(allKits, trimmed, limit)
-
-  return { query: trimmed, hits, warnings }
-}
-
-// ── Index loading with cache ────────────────────────────────────────────────
-
-async function loadIndex(url: string): Promise<RegistryIndex | null> {
-  const cachePath = indexCachePath(url)
-  const cached = readCachedIndex(cachePath)
-
-  // Fresh cache: return immediately
-  if (cached && !isCacheExpired(cached.mtime)) {
-    return cached.index
-  }
-
-  // Try to fetch fresh index
-  try {
-    const response = await fetchWithTimeout(url, undefined, 10_000)
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`)
-    }
-    const data = (await response.json()) as unknown
-    const index = parseRegistryIndex(data)
-    if (index) {
-      writeCachedIndex(cachePath, index)
-      return index
-    }
-    throw new Error("Invalid registry index format")
-  } catch (err) {
-    // Fetch failed — use stale cache if available
-    if (cached && !isCacheStale(cached.mtime)) {
-      return cached.index
-    }
-    throw err
-  }
-}
-
-function readCachedIndex(
-  cachePath: string,
-): { index: RegistryIndex; mtime: number } | null {
-  try {
-    const stat = fs.statSync(cachePath)
-    const raw = JSON.parse(fs.readFileSync(cachePath, "utf8"))
-    const index = parseRegistryIndex(raw)
-    if (!index) return null
-    return { index, mtime: stat.mtimeMs }
-  } catch {
-    return null
-  }
-}
-
-function writeCachedIndex(cachePath: string, index: RegistryIndex): void {
-  try {
-    const dir = path.dirname(cachePath)
-    fs.mkdirSync(dir, { recursive: true })
-    const tmpPath = cachePath + `.tmp.${process.pid}`
-    fs.writeFileSync(tmpPath, JSON.stringify(index), "utf8")
-    fs.renameSync(tmpPath, cachePath)
-  } catch {
-    // Best-effort caching — don't fail the search if we can't write
-  }
-}
-
-function indexCachePath(url: string): string {
-  const cacheRoot = resolveCacheDir()
-  // Deterministic filename from URL
-  const slug = url
-    .replace(/[^a-zA-Z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 120)
-  return path.join(cacheRoot, "registry-index", `${slug}.json`)
-}
-
-function resolveCacheDir(): string {
-  const xdgCache = process.env.XDG_CACHE_HOME?.trim()
-  if (xdgCache) return path.join(path.resolve(xdgCache), "agentikit")
-  const home = process.env.HOME?.trim()
-  if (!home) return path.join("/tmp", "agentikit-cache")
-  return path.join(path.resolve(home), ".cache", "agentikit")
-}
-
-function isCacheExpired(mtimeMs: number): boolean {
-  return Date.now() - mtimeMs > CACHE_TTL_MS
-}
-
-function isCacheStale(mtimeMs: number): boolean {
-  return Date.now() - mtimeMs > CACHE_STALE_MS
-}
-
-// ── Index parsing ───────────────────────────────────────────────────────────
-
-function parseRegistryIndex(data: unknown): RegistryIndex | null {
-  if (typeof data !== "object" || data === null || Array.isArray(data)) return null
-  const obj = data as Record<string, unknown>
-
-  if (typeof obj.version !== "number" || obj.version !== 1) return null
-  if (typeof obj.updatedAt !== "string") return null
-  if (!Array.isArray(obj.kits)) return null
-
-  const kits = obj.kits.flatMap((raw): RegistryKitEntry[] => {
-    const kit = parseKitEntry(raw)
-    return kit ? [kit] : []
-  })
-
-  return { version: 1, updatedAt: obj.updatedAt, kits }
-}
-
-function parseKitEntry(raw: unknown): RegistryKitEntry | null {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null
-  const obj = raw as Record<string, unknown>
-
-  const id = asString(obj.id)
-  const name = asString(obj.name)
-  const ref = asString(obj.ref)
-  const source = asSource(obj.source)
-  if (!id || !name || !ref || !source) return null
-
-  return {
-    id,
-    name,
-    ref,
-    source,
-    description: asString(obj.description),
-    homepage: asString(obj.homepage),
-    tags: asStringArray(obj.tags),
-    assetTypes: asStringArray(obj.assetTypes),
-    author: asString(obj.author),
-    license: asString(obj.license),
-    latestVersion: asString(obj.latestVersion),
-    curated: obj.curated === true ? true : undefined,
-  }
-}
-
-// ── Scoring ─────────────────────────────────────────────────────────────────
-
-function scoreKits(
-  kits: RegistryKitEntry[],
-  query: string,
-  limit: number,
-): RegistrySearchHit[] {
-  const tokens = query
-    .toLowerCase()
-    .split(/\s+/)
-    .filter(Boolean)
-
-  const scored: Array<{ kit: RegistryKitEntry; score: number }> = []
-
-  for (const kit of kits) {
-    const score = scoreKit(kit, tokens)
-    if (score > 0) {
-      scored.push({ kit, score })
-    }
-  }
-
-  scored.sort((a, b) => b.score - a.score)
-
-  return scored.slice(0, limit).map(({ kit, score }) => toSearchHit(kit, score))
-}
-
-function scoreKit(kit: RegistryKitEntry, tokens: string[]): number {
-  let score = 0
-  const nameLower = kit.name.toLowerCase()
-  const descLower = (kit.description ?? "").toLowerCase()
-  const tagsLower = (kit.tags ?? []).map((t) => t.toLowerCase())
-
-  for (const token of tokens) {
-    // Exact name match is strongest signal
-    if (nameLower === token) {
-      score += 1.0
-    } else if (nameLower.includes(token)) {
-      score += 0.6
-    }
-
-    // Tag matches are high-signal (curated keywords)
-    if (tagsLower.some((tag) => tag === token)) {
-      score += 0.5
-    } else if (tagsLower.some((tag) => tag.includes(token))) {
-      score += 0.25
-    }
-
-    // Description substring
-    if (descLower.includes(token)) {
-      score += 0.2
-    }
-
-    // Author match
-    if (kit.author?.toLowerCase().includes(token)) {
-      score += 0.15
-    }
-  }
-
-  // Normalize by token count so multi-word queries don't inflate scores
-  return tokens.length > 0 ? score / tokens.length : 0
-}
-
-function toSearchHit(kit: RegistryKitEntry, score: number): RegistrySearchHit {
-  const metadata: Record<string, string> = {}
-  if (kit.latestVersion) metadata.version = kit.latestVersion
-  if (kit.author) metadata.author = kit.author
-  if (kit.license) metadata.license = kit.license
-  if (kit.assetTypes?.length) metadata.assetTypes = kit.assetTypes.join(", ")
-
-  return {
-    source: kit.source,
-    id: kit.id,
-    title: kit.name,
-    description: kit.description,
-    ref: kit.ref,
-    homepage: kit.homepage,
-    score: Math.round(score * 1000) / 1000,
-    metadata,
-    curated: kit.curated,
-  }
-}
-
-// ── Registry URL resolution ─────────────────────────────────────────────────
-
-function resolveRegistryUrls(override?: string | string[]): string[] {
-  if (override) {
-    const urls = Array.isArray(override) ? override : [override]
-    return urls.filter(Boolean)
-  }
-
-  // Allow env var override (comma-separated)
-  const envUrls = process.env.AKM_REGISTRY_URL?.trim()
-  if (envUrls) {
-    return envUrls.split(",").map((u) => u.trim()).filter(Boolean)
-  }
-
-  return [DEFAULT_REGISTRY_URL]
-}
-
-// ── Utilities ───────────────────────────────────────────────────────────────
-
-function clampLimit(limit: number | undefined): number {
-  if (!limit || !Number.isFinite(limit)) return 20
-  return Math.min(100, Math.max(1, Math.trunc(limit)))
-}
-
-function asString(value: unknown): string | undefined {
-  return typeof value === "string" && value ? value : undefined
-}
-
-function asSource(value: unknown): "npm" | "github" | "git" | undefined {
-  return value === "npm" || value === "github" || value === "git"
-    ? value
-    : undefined
-}
-
-function asStringArray(value: unknown): string[] | undefined {
-  if (!Array.isArray(value)) return undefined
-  const filtered = value.filter((v): v is string => typeof v === "string")
-  return filtered.length > 0 ? filtered : undefined
-}
-
-function toErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error)
-}

package/src/registry-types.ts

@@ -1,72 +0,0 @@
-export type RegistrySource = "npm" | "github" | "git"
-
-export interface RegistryRefBase {
-  source: RegistrySource
-  ref: string
-  id: string
-}
-
-export interface ParsedNpmRef extends RegistryRefBase {
-  source: "npm"
-  packageName: string
-  requestedVersionOrTag?: string
-}
-
-export interface ParsedGithubRef extends RegistryRefBase {
-  source: "github"
-  owner: string
-  repo: string
-  requestedRef?: string
-}
-
-export interface ParsedGitRef extends RegistryRefBase {
-  source: "git"
-  repoRoot: string
-  sourcePath: string
-}
-
-export type ParsedRegistryRef = ParsedNpmRef | ParsedGithubRef | ParsedGitRef
-
-export interface ResolvedRegistryArtifact {
-  id: string
-  source: RegistrySource
-  ref: string
-  artifactUrl: string
-  resolvedVersion?: string
-  resolvedRevision?: string
-}
-
-export interface RegistryInstalledEntry {
-  id: string
-  source: RegistrySource
-  ref: string
-  resolvedVersion?: string
-  resolvedRevision?: string
-  artifactUrl: string
-  stashRoot: string
-  cacheDir: string
-  installedAt: string
-}
-
-export interface RegistryInstallResult extends RegistryInstalledEntry {
-  extractedDir: string
-}
-
-export interface RegistrySearchHit {
-  source: RegistrySource
-  id: string
-  title: string
-  description?: string
-  ref: string
-  homepage?: string
-  score?: number
-  metadata?: Record<string, string>
-  /** Whether this entry was manually reviewed and approved */
-  curated?: boolean
-}
-
-export interface RegistrySearchResponse {
-  query: string
-  hits: RegistrySearchHit[]
-  warnings: string[]
-}

package/src/ripgrep-install.ts

@@ -1,200 +0,0 @@
-import { spawnSync } from "node:child_process"
-import fs from "node:fs"
-import path from "node:path"
-import { IS_WINDOWS } from "./common"
-import { RG_BINARY, resolveRg } from "./ripgrep-resolve"
-
-/**
- * Platform and architecture detection for ripgrep binary downloads.
- */
-function getRgPlatformTarget(): { platform: string; arch: string; ext: string } | null {
-  const platform = process.platform
-  const arch = process.arch
-
-  if (platform === "linux" && arch === "x64") {
-    return { platform: "x86_64-unknown-linux-musl", arch: "x64", ext: ".tar.gz" }
-  }
-  if (platform === "linux" && arch === "arm64") {
-    return { platform: "aarch64-unknown-linux-gnu", arch: "arm64", ext: ".tar.gz" }
-  }
-  if (platform === "darwin" && arch === "x64") {
-    return { platform: "x86_64-apple-darwin", arch: "x64", ext: ".tar.gz" }
-  }
-  if (platform === "darwin" && arch === "arm64") {
-    return { platform: "aarch64-apple-darwin", arch: "arm64", ext: ".tar.gz" }
-  }
-  if (platform === "win32" && arch === "x64") {
-    return { platform: "x86_64-pc-windows-msvc", arch: "x64", ext: ".zip" }
-  }
-
-  return null
-}
-
-const RG_VERSION = "14.1.1"
-
-export interface EnsureRgResult {
-  rgPath: string
-  installed: boolean
-  version: string
-}
-
-/**
- * Ensure ripgrep is available. If not found on PATH or in stash/bin,
- * download and install it to stash/bin.
- *
- * Returns the path to the ripgrep binary and whether it was newly installed.
- */
-export function ensureRg(stashDir: string): EnsureRgResult {
-  // Already available?
-  const existing = resolveRg(stashDir)
-  if (existing) {
-    return { rgPath: existing, installed: false, version: getRgVersion(existing) }
-  }
-
-  // Determine platform
-  const target = getRgPlatformTarget()
-  if (!target) {
-    throw new Error(
-      `Unsupported platform for ripgrep auto-install: ${process.platform}/${process.arch}. ` +
-      `Install ripgrep manually: https://github.com/BurntSushi/ripgrep#installation`
-    )
-  }
-
-  const binDir = path.join(stashDir, "bin")
-  if (!fs.existsSync(binDir)) {
-    fs.mkdirSync(binDir, { recursive: true })
-  }
-
-  const archiveName = `ripgrep-${RG_VERSION}-${target.platform}`
-  const url = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${archiveName}${target.ext}`
-  const destBinary = path.join(binDir, RG_BINARY)
-
-  if (target.ext === ".tar.gz") {
-    downloadAndExtractTarGz(url, archiveName, destBinary)
-  } else {
-    downloadAndExtractZip(url, archiveName, destBinary)
-  }
-
-  // Make executable
-  if (!IS_WINDOWS) {
-    fs.chmodSync(destBinary, 0o755)
-  }
-
-  return { rgPath: destBinary, installed: true, version: RG_VERSION }
-}
-
-function downloadAndExtractTarGz(url: string, archiveName: string, destBinary: string): void {
-  const destDir = path.dirname(destBinary)
-  const tmpTarGz = path.join(destDir, "rg-download.tar.gz")
-
-  try {
-    // Download archive to a temporary file without using a shell
-    const curlResult = spawnSync(
-      "curl",
-      ["-fsSL", "-o", tmpTarGz, url],
-      {
-        encoding: "utf8",
-        timeout: 60_000,
-      }
-    )
-
-    if (curlResult.status !== 0) {
-      const err = curlResult.stderr?.trim() || curlResult.error?.message || "unknown error"
-      throw new Error(`Failed to download ripgrep from ${url}: ${err}`)
-    }
-
-    // Extract the specific binary from the archive into destDir
-    const tarResult = spawnSync(
-      "tar",
-      [
-        "xzf",
-        tmpTarGz,
-        "--strip-components=1",
-        "-C",
-        destDir,
-        `${archiveName}/rg`,
-      ],
-      {
-        encoding: "utf8",
-        timeout: 60_000,
-      }
-    )
-
-    if (tarResult.status !== 0) {
-      const err = tarResult.stderr?.trim() || tarResult.error?.message || "unknown error"
-      throw new Error(`Failed to extract ripgrep from ${url}: ${err}`)
-    }
-
-    if (!fs.existsSync(destBinary)) {
-      throw new Error(`ripgrep binary not found at ${destBinary} after extraction`)
-    }
-  } finally {
-    // Best-effort cleanup of temporary archive
-    try {
-      if (fs.existsSync(tmpTarGz)) {
-        fs.unlinkSync(tmpTarGz)
-      }
-    } catch {
-      // ignore cleanup errors
-    }
-  }
-}
-
-function downloadAndExtractZip(url: string, archiveName: string, destBinary: string): void {
-  const destDir = path.dirname(destBinary)
-  const tmpZip = path.join(destDir, "rg-download.zip")
-  const expandedDir = path.join(destDir, archiveName)
-  try {
-    // Download
-    const dlResult = spawnSync("curl", ["-fsSL", "-o", tmpZip, url], {
-      encoding: "utf8",
-      timeout: 60_000,
-    })
-    if (dlResult.status !== 0) {
-      throw new Error(dlResult.stderr?.trim() || "download failed")
-    }
-
-    // Extract the zip archive using separate spawnSync calls with argument arrays
-    // to avoid shell injection via path interpolation in PowerShell -Command strings
-    const expandResult = spawnSync("powershell", [
-      "-Command",
-      "Expand-Archive",
-      "-Path", tmpZip,
-      "-DestinationPath", destDir,
-      "-Force",
-    ], {
-      encoding: "utf8",
-      timeout: 60_000,
-    })
-    if (expandResult.status !== 0) {
-      throw new Error(expandResult.stderr?.trim() || "extraction failed")
-    }
-
-    const srcRgExe = path.join(destDir, archiveName, "rg.exe")
-    const moveResult = spawnSync("powershell", [
-      "-Command",
-      "Move-Item",
-      "-Force",
-      "-Path", srcRgExe,
-      "-Destination", destBinary,
-    ], {
-      encoding: "utf8",
-      timeout: 60_000,
-    })
-    if (moveResult.status !== 0) {
-      throw new Error(moveResult.stderr?.trim() || "move failed")
-    }
-  } finally {
-    if (fs.existsSync(tmpZip)) fs.unlinkSync(tmpZip)
-    if (fs.existsSync(expandedDir)) fs.rmSync(expandedDir, { recursive: true, force: true })
-  }
-}
-
-function getRgVersion(rgPath: string): string {
-  const result = spawnSync(rgPath, ["--version"], { encoding: "utf8", timeout: 5_000 })
-  if (result.status === 0 && result.stdout) {
-    const match = result.stdout.match(/ripgrep\s+([\d.]+)/)
-    return match ? match[1] : "unknown"
-  }
-  return "unknown"
-}

package/src/ripgrep-resolve.ts

@@ -1,72 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import { IS_WINDOWS } from "./common"
-
-export const RG_BINARY = IS_WINDOWS ? "rg.exe" : "rg"
-
-function canExecute(filePath: string): boolean {
-  if (!fs.existsSync(filePath)) return false
-  if (IS_WINDOWS) return true
-  try {
-    fs.accessSync(filePath, fs.constants.X_OK)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function resolveFromPath(): string | null {
-  const rawPath = process.env.PATH
-  if (!rawPath) return null
-
-  const pathEntries = rawPath.split(path.delimiter).filter(Boolean)
-
-  if (IS_WINDOWS) {
-    const pathext = (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM")
-      .split(";")
-      .filter(Boolean)
-      .map((ext) => ext.toLowerCase())
-
-    for (const entry of pathEntries) {
-      const directCandidate = path.join(entry, "rg")
-      if (canExecute(directCandidate)) return directCandidate
-
-      for (const ext of pathext) {
-        const candidate = path.join(entry, `rg${ext}`)
-        if (canExecute(candidate)) return candidate
-      }
-    }
-    return null
-  }
-
-  for (const entry of pathEntries) {
-    const candidate = path.join(entry, "rg")
-    if (canExecute(candidate)) return candidate
-  }
-
-  return null
-}
-
-/**
- * Resolve the path to a usable ripgrep binary.
- * Checks in order:
- *   1. stashDir/bin/rg
- *   2. system PATH (rg)
- * Returns null if ripgrep is not available.
- */
-export function resolveRg(stashDir?: string): string | null {
-  // Check stash bin directory first
-  if (stashDir) {
-    const stashRg = path.join(stashDir, "bin", RG_BINARY)
-    if (canExecute(stashRg)) return stashRg
-  }
-
-  return resolveFromPath()
-}
-
-/**
- * Check if ripgrep is available (either in stash/bin or system PATH).
- */
-export function isRgAvailable(stashDir?: string): boolean {
-  return resolveRg(stashDir) !== null
-}

package/src/ripgrep.ts

@@ -1,3 +0,0 @@
-export { resolveRg, isRgAvailable } from "./ripgrep-resolve"
-export { ensureRg } from "./ripgrep-install"
-export type { EnsureRgResult } from "./ripgrep-install"