agentikit 0.0.13 → 0.0.14

package/src/stash-add.ts

@@ -1,63 +0,0 @@
-import { agentikitIndex } from "./indexer"
-import fs from "node:fs"
-import { resolveStashDir } from "./common"
-import { loadConfig } from "./config"
-import { upsertInstalledRegistryEntry, installRegistryRef } from "./registry-install"
-import type { AddResponse } from "./stash-types"
-
-export async function agentikitAdd(input: { ref: string }): Promise<AddResponse> {
-  const ref = input.ref.trim()
-  if (!ref) throw new Error("Install ref or local git directory is required.")
-
-  const stashDir = resolveStashDir()
-  const installed = await installRegistryRef(ref)
-  const replaced = loadConfig().registry?.installed.find((entry) => entry.id === installed.id)
-  const config = upsertInstalledRegistryEntry({
-    id: installed.id,
-    source: installed.source,
-    ref: installed.ref,
-    artifactUrl: installed.artifactUrl,
-    resolvedVersion: installed.resolvedVersion,
-    resolvedRevision: installed.resolvedRevision,
-    stashRoot: installed.stashRoot,
-    cacheDir: installed.cacheDir,
-    installedAt: installed.installedAt,
-  })
-
-  if (replaced && replaced.cacheDir !== installed.cacheDir) {
-    try {
-      fs.rmSync(replaced.cacheDir, { recursive: true, force: true })
-    } catch {
-      // Best-effort cleanup only.
-    }
-  }
-
-  const index = await agentikitIndex({ stashDir })
-
-  return {
-    stashDir,
-    ref,
-    installed: {
-      id: installed.id,
-      source: installed.source,
-      ref: installed.ref,
-      artifactUrl: installed.artifactUrl,
-      resolvedVersion: installed.resolvedVersion,
-      resolvedRevision: installed.resolvedRevision,
-      stashRoot: installed.stashRoot,
-      cacheDir: installed.cacheDir,
-      extractedDir: installed.extractedDir,
-      installedAt: installed.installedAt,
-    },
-    config: {
-      mountedStashDirs: config.mountedStashDirs,
-      installedRegistryCount: config.registry?.installed.length ?? 0,
-    },
-    index: {
-      mode: index.mode,
-      totalEntries: index.totalEntries,
-      directoriesScanned: index.directoriesScanned,
-      directoriesSkipped: index.directoriesSkipped,
-    },
-  }
-}

package/src/stash-clone.ts

@@ -1,127 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import { TYPE_DIRS } from "./asset-spec"
-import { parseAssetRef, makeAssetRef } from "./stash-ref"
-import { resolveSourcesForOrigin } from "./origin-resolve"
-import { resolveAssetPath } from "./stash-resolve"
-import { resolveStashSources, findSourceForPath, type StashSource, type StashSourceKind } from "./stash-source"
-
-export interface CloneOptions {
-  /** Source ref (e.g., npm:@scope/pkg//tool:deploy.sh) */
-  sourceRef: string
-  /** Optional new name for the cloned asset */
-  newName?: string
-  /** If true, overwrite existing asset in working stash */
-  force?: boolean
-}
-
-export interface CloneResponse {
-  source: {
-    path: string
-    sourceKind: StashSourceKind
-    registryId?: string
-  }
-  destination: {
-    path: string
-    ref: string
-  }
-  overwritten: boolean
-}
-
-export async function agentikitClone(options: CloneOptions): Promise<CloneResponse> {
-  const parsed = parseAssetRef(options.sourceRef)
-  const allSources = resolveStashSources()
-  const workingSource = allSources.find((s) => s.kind === "working")
-  if (!workingSource) {
-    throw new Error("No working stash configured. Run `akm init` first.")
-  }
-
-  const searchSources = resolveSourcesForOrigin(parsed.origin, allSources)
-
-  let sourcePath: string | undefined
-  let lastError: Error | undefined
-  for (const source of searchSources) {
-    try {
-      sourcePath = resolveAssetPath(source.path, parsed.type, parsed.name)
-      break
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err))
-    }
-  }
-  if (!sourcePath) {
-    throw lastError ?? new Error(`Source asset not found for ref: ${options.sourceRef}`)
-  }
-
-  const sourceSource = findSourceForPath(sourcePath, allSources)
-  const sourceKind = sourceSource?.kind ?? "working"
-
-  const destName = options.newName ?? parsed.name
-  const typeDir = TYPE_DIRS[parsed.type]
-  const workingDir = workingSource.path
-
-  // Guard against self-clone
-  if (parsed.type === "skill") {
-    const sourceSkillDir = path.resolve(path.dirname(sourcePath))
-    const destSkillDir = path.resolve(path.join(workingDir, typeDir, destName))
-    if (sourceSkillDir === destSkillDir) {
-      throw new Error(
-        `Source and destination are the same path. Use --name to provide a new name for the clone.`,
-      )
-    }
-  } else {
-    const resolvedSource = path.resolve(sourcePath)
-    const resolvedDest = path.resolve(path.join(workingDir, typeDir, destName))
-    if (resolvedSource === resolvedDest) {
-      throw new Error(
-        `Source and destination are the same path. Use --name to provide a new name for the clone.`,
-      )
-    }
-  }
-
-  let destPath: string
-  if (parsed.type === "skill") {
-    const sourceSkillDir = path.dirname(sourcePath)
-    const destSkillDir = path.join(workingDir, typeDir, destName)
-    const overwritten = fs.existsSync(destSkillDir)
-
-    if (overwritten && !options.force) {
-      throw new Error(
-        `Asset already exists in working stash: ${destSkillDir}. Use --force to overwrite.`,
-      )
-    }
-
-    if (overwritten) {
-      fs.rmSync(destSkillDir, { recursive: true, force: true })
-    }
-    fs.cpSync(sourceSkillDir, destSkillDir, { recursive: true })
-
-    destPath = path.join(destSkillDir, "SKILL.md")
-    const ref = makeAssetRef(parsed.type, destName, "local")
-
-    return {
-      source: { path: sourcePath, sourceKind, registryId: sourceSource?.registryId },
-      destination: { path: destPath, ref },
-      overwritten,
-    }
-  }
-
-  destPath = path.join(workingDir, typeDir, destName)
-  const overwritten = fs.existsSync(destPath)
-
-  if (overwritten && !options.force) {
-    throw new Error(
-      `Asset already exists in working stash: ${destPath}. Use --force to overwrite.`,
-    )
-  }
-
-  fs.mkdirSync(path.dirname(destPath), { recursive: true })
-  fs.copyFileSync(sourcePath, destPath)
-
-  const ref = makeAssetRef(parsed.type, destName, "local")
-
-  return {
-    source: { path: sourcePath, sourceKind, registryId: sourceSource?.registryId },
-    destination: { path: destPath, ref },
-    overwritten,
-  }
-}

package/src/stash-ref.ts

@@ -1,99 +0,0 @@
-import path from "node:path"
-import { type AgentikitAssetType, isAssetType } from "./common"
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export interface AssetRef {
-  type: AgentikitAssetType
-  name: string
-  /**
-   * Where to find this asset.
-   *   - undefined: search all sources (working → mounted → installed)
-   *   - "local": working stash only
-   *   - registry ref: e.g. "npm:@scope/pkg", "owner/repo", "github:owner/repo#v1"
-   *   - filesystem path: e.g. "/mnt/shared-stash"
-   */
-  origin?: string
-}
-
-// ── Construction ────────────────────────────────────────────────────────────
-
-/**
- * Build a ref string from components.
- *
- * Examples:
- *   makeAssetRef("tool", "deploy.sh")
- *     → "tool:deploy.sh"
- *   makeAssetRef("tool", "deploy.sh", "npm:@scope/pkg")
- *     → "npm:@scope/pkg//tool:deploy.sh"
- *   makeAssetRef("skill", "code-review", "local")
- *     → "local//skill:code-review"
- *   makeAssetRef("tool", "db/migrate/run.sh", "owner/repo")
- *     → "owner/repo//tool:db/migrate/run.sh"
- */
-export function makeAssetRef(
-  type: AgentikitAssetType,
-  name: string,
-  origin?: string,
-): string {
-  validateName(name)
-  const normalized = normalizeName(name)
-  const asset = `${type}:${normalized}`
-  if (!origin) return asset
-  return `${origin}//${asset}`
-}
-
-// ── Parsing ─────────────────────────────────────────────────────────────────
-
-/**
- * Parse a ref string in the format `[origin//]type:name`.
- */
-export function parseAssetRef(ref: string): AssetRef {
-  const trimmed = ref.trim()
-  if (!trimmed) throw new Error("Empty ref.")
-
-  let origin: string | undefined
-  let body = trimmed
-
-  const boundary = trimmed.indexOf("//")
-  if (boundary >= 0) {
-    origin = trimmed.slice(0, boundary)
-    body = trimmed.slice(boundary + 2)
-    if (!origin) throw new Error("Empty origin in ref.")
-  }
-
-  const colon = body.indexOf(":")
-  if (colon <= 0) {
-    throw new Error(`Invalid ref "${trimmed}". Expected [origin//]type:name`)
-  }
-
-  const rawType = body.slice(0, colon)
-  const rawName = body.slice(colon + 1)
-
-  if (!isAssetType(rawType)) {
-    throw new Error(`Invalid asset type: "${rawType}".`)
-  }
-
-  validateName(rawName)
-  const name = normalizeName(rawName)
-
-  return { type: rawType, name, origin: origin || undefined }
-}
-
-// ── Validation ──────────────────────────────────────────────────────────────
-
-function validateName(name: string): void {
-  if (!name) throw new Error("Empty asset name.")
-  if (name.includes("\0")) throw new Error("Null byte in asset name.")
-  if (/^[A-Za-z]:/.test(name)) throw new Error("Windows drive path in asset name.")
-
-  const normalized = path.posix.normalize(name.replace(/\\/g, "/"))
-  if (path.posix.isAbsolute(normalized)) throw new Error("Absolute path in asset name.")
-  if (normalized === ".." || normalized.startsWith("../")) {
-    throw new Error("Path traversal in asset name.")
-  }
-}
-
-function normalizeName(name: string): string {
-  return path.posix.normalize(name.replace(/\\/g, "/"))
-}

package/src/stash-registry.ts

@@ -1,259 +0,0 @@
-import fs from "node:fs"
-import { resolveStashDir } from "./common"
-import { loadConfig } from "./config"
-import { agentikitIndex } from "./indexer"
-import {
-  installRegistryRef,
-  removeInstalledRegistryEntry,
-  upsertInstalledRegistryEntry,
-} from "./registry-install"
-import { parseRegistryRef } from "./registry-resolve"
-import type { RegistryInstalledEntry } from "./registry-types"
-import type {
-  ListResponse,
-  RegistryInstallStatus,
-  RemoveResponse,
-  ReinstallResponse,
-  UpdateResponse,
-} from "./stash-types"
-
-export async function agentikitList(input?: { stashDir?: string }): Promise<ListResponse> {
-  const stashDir = input?.stashDir ?? resolveStashDir()
-  const config = loadConfig()
-  const installed = config.registry?.installed ?? []
-
-  return {
-    stashDir,
-    installed: installed.map((entry) => ({
-      ...entry,
-      status: {
-        cacheDirExists: directoryExists(entry.cacheDir),
-        stashRootExists: directoryExists(entry.stashRoot),
-      },
-    })),
-    totalInstalled: installed.length,
-  }
-}
-
-export async function agentikitRemove(input: { target: string; stashDir?: string }): Promise<RemoveResponse> {
-  const target = input.target.trim()
-  if (!target) throw new Error("Target is required.")
-
-  const stashDir = input.stashDir ?? resolveStashDir()
-  const config = loadConfig()
-  const installed = config.registry?.installed ?? []
-  const entry = resolveInstalledTarget(installed, target)
-
-  const updatedConfig = removeInstalledRegistryEntry(entry.id)
-  cleanupDirectoryBestEffort(entry.cacheDir)
-  const index = await agentikitIndex({ stashDir })
-
-  return {
-    stashDir,
-    target,
-    removed: {
-      id: entry.id,
-      source: entry.source,
-      ref: entry.ref,
-      cacheDir: entry.cacheDir,
-      stashRoot: entry.stashRoot,
-    },
-    config: {
-      mountedStashDirs: updatedConfig.mountedStashDirs,
-      installedRegistryCount: updatedConfig.registry?.installed.length ?? 0,
-    },
-    index: {
-      mode: index.mode,
-      totalEntries: index.totalEntries,
-      directoriesScanned: index.directoriesScanned,
-      directoriesSkipped: index.directoriesSkipped,
-    },
-  }
-}
-
-export async function agentikitReinstall(input?: {
-  target?: string
-  all?: boolean
-  stashDir?: string
-}): Promise<ReinstallResponse> {
-  const stashDir = input?.stashDir ?? resolveStashDir()
-  const target = input?.target?.trim()
-  const all = input?.all === true
-  const installedEntries = loadConfig().registry?.installed ?? []
-  const selectedEntries = selectTargets(installedEntries, target, all)
-
-  const processed: ReinstallResponse["processed"] = []
-  for (const entry of selectedEntries) {
-    const installed = await installRegistryRef(entry.ref)
-    upsertInstalledRegistryEntry(toInstalledEntry(installed))
-    if (entry.cacheDir !== installed.cacheDir) {
-      cleanupDirectoryBestEffort(entry.cacheDir)
-    }
-
-    processed.push({
-      id: entry.id,
-      source: entry.source,
-      ref: entry.ref,
-      previousCacheDir: entry.cacheDir,
-      installed: toInstallStatus(installed),
-    })
-  }
-
-  const index = await agentikitIndex({ stashDir })
-  const config = loadConfig()
-
-  return {
-    stashDir,
-    target,
-    all,
-    processed,
-    config: {
-      mountedStashDirs: config.mountedStashDirs,
-      installedRegistryCount: config.registry?.installed.length ?? 0,
-    },
-    index: {
-      mode: index.mode,
-      totalEntries: index.totalEntries,
-      directoriesScanned: index.directoriesScanned,
-      directoriesSkipped: index.directoriesSkipped,
-    },
-  }
-}
-
-export async function agentikitUpdate(input?: {
-  target?: string
-  all?: boolean
-  stashDir?: string
-}): Promise<UpdateResponse> {
-  const stashDir = input?.stashDir ?? resolveStashDir()
-  const target = input?.target?.trim()
-  const all = input?.all === true
-  const installedEntries = loadConfig().registry?.installed ?? []
-  const selectedEntries = selectTargets(installedEntries, target, all)
-
-  const processed: UpdateResponse["processed"] = []
-  for (const entry of selectedEntries) {
-    const installed = await installRegistryRef(entry.ref)
-    upsertInstalledRegistryEntry(toInstalledEntry(installed))
-    if (entry.cacheDir !== installed.cacheDir) {
-      cleanupDirectoryBestEffort(entry.cacheDir)
-    }
-
-    const versionChanged = (entry.resolvedVersion ?? "") !== (installed.resolvedVersion ?? "")
-    const revisionChanged = (entry.resolvedRevision ?? "") !== (installed.resolvedRevision ?? "")
-
-    processed.push({
-      id: entry.id,
-      source: entry.source,
-      ref: entry.ref,
-      previous: {
-        resolvedVersion: entry.resolvedVersion,
-        resolvedRevision: entry.resolvedRevision,
-        cacheDir: entry.cacheDir,
-      },
-      installed: toInstallStatus(installed),
-      changed: {
-        version: versionChanged,
-        revision: revisionChanged,
-        any: versionChanged || revisionChanged,
-      },
-    })
-  }
-
-  const index = await agentikitIndex({ stashDir })
-  const config = loadConfig()
-
-  return {
-    stashDir,
-    target,
-    all,
-    processed,
-    config: {
-      mountedStashDirs: config.mountedStashDirs,
-      installedRegistryCount: config.registry?.installed.length ?? 0,
-    },
-    index: {
-      mode: index.mode,
-      totalEntries: index.totalEntries,
-      directoriesScanned: index.directoriesScanned,
-      directoriesSkipped: index.directoriesSkipped,
-    },
-  }
-}
-
-function selectTargets(installed: RegistryInstalledEntry[], target: string | undefined, all: boolean): RegistryInstalledEntry[] {
-  if (all && target) {
-    throw new Error("Specify either <target> or --all, not both.")
-  }
-  if (all) return installed
-  if (!target) {
-    throw new Error("Either <target> or --all is required.")
-  }
-  return [resolveInstalledTarget(installed, target)]
-}
-
-function resolveInstalledTarget(installed: RegistryInstalledEntry[], target: string): RegistryInstalledEntry {
-  const byId = installed.find((entry) => entry.id === target)
-  if (byId) return byId
-
-  const byRef = installed.find((entry) => entry.ref === target)
-  if (byRef) return byRef
-
-  let parsedId: string | undefined
-  try {
-    parsedId = parseRegistryRef(target).id
-  } catch {
-    parsedId = undefined
-  }
-  if (parsedId) {
-    const byParsedId = installed.find((entry) => entry.id === parsedId)
-    if (byParsedId) return byParsedId
-  }
-
-  throw new Error(`No installed registry entry matched target: ${target}`)
-}
-
-function toInstalledEntry(status: RegistryInstallStatus): RegistryInstalledEntry {
-  return {
-    id: status.id,
-    source: status.source,
-    ref: status.ref,
-    artifactUrl: status.artifactUrl,
-    resolvedVersion: status.resolvedVersion,
-    resolvedRevision: status.resolvedRevision,
-    stashRoot: status.stashRoot,
-    cacheDir: status.cacheDir,
-    installedAt: status.installedAt,
-  }
-}
-
-function toInstallStatus(status: RegistryInstallStatus): RegistryInstallStatus {
-  return {
-    id: status.id,
-    source: status.source,
-    ref: status.ref,
-    artifactUrl: status.artifactUrl,
-    resolvedVersion: status.resolvedVersion,
-    resolvedRevision: status.resolvedRevision,
-    stashRoot: status.stashRoot,
-    cacheDir: status.cacheDir,
-    extractedDir: status.extractedDir,
-    installedAt: status.installedAt,
-  }
-}
-
-function cleanupDirectoryBestEffort(target: string): void {
-  try {
-    fs.rmSync(target, { recursive: true, force: true })
-  } catch {
-    // Best-effort cleanup only.
-  }
-}
-
-function directoryExists(target: string): boolean {
-  try {
-    return fs.statSync(target).isDirectory()
-  } catch {
-    return false
-  }
-}

package/src/stash-resolve.ts

@@ -1,50 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import { type AgentikitAssetType, hasErrnoCode, isWithin } from "./common"
-import { TYPE_DIRS, isRelevantAssetFile, resolveAssetPathFromName } from "./asset-spec"
-
-export function resolveAssetPath(stashDir: string, type: AgentikitAssetType, name: string): string {
-  const root = path.join(stashDir, TYPE_DIRS[type])
-  const target = resolveAssetPathFromName(type, root, name)
-  const resolvedRoot = resolveAndValidateTypeRoot(root, type, name)
-  const resolvedTarget = path.resolve(target)
-  if (!isWithin(resolvedTarget, resolvedRoot)) {
-    throw new Error("Ref resolves outside the stash root.")
-  }
-  if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isFile()) {
-    throw new Error(`Stash asset not found for ref: ${type}:${name}`)
-  }
-  const realTarget = fs.realpathSync(resolvedTarget)
-  if (!isWithin(realTarget, resolvedRoot)) {
-    throw new Error("Ref resolves outside the stash root.")
-  }
-  if (!isRelevantAssetFile(type, path.basename(resolvedTarget))) {
-    if (type === "tool") {
-      throw new Error("Tool ref must resolve to a .sh, .ts, .js, .ps1, .cmd, or .bat file.")
-    }
-    if (type === "script") {
-      throw new Error("Script ref must resolve to a file with a supported script extension. Refer to the Agentikit documentation for the complete list of supported script extensions.");
-    }
-    throw new Error(`Stash asset not found for ref: ${type}:${name}`)
-  }
-  return realTarget
-}
-
-function resolveAndValidateTypeRoot(root: string, type: AgentikitAssetType, name: string): string {
-  const rootStat = readTypeRootStat(root, type, name)
-  if (!rootStat.isDirectory()) {
-    throw new Error(`Stash type root is not a directory for ref: ${type}:${name}`)
-  }
-  return fs.realpathSync(root)
-}
-
-function readTypeRootStat(root: string, type: AgentikitAssetType, name: string): fs.Stats {
-  try {
-    return fs.statSync(root)
-  } catch (error: unknown) {
-    if (hasErrnoCode(error, "ENOENT")) {
-      throw new Error(`Stash type root not found for ref: ${type}:${name}`)
-    }
-    throw error
-  }
-}