unagent 0.0.1 → 0.0.4

package/dist/git-D3qsdy9d.mjs

@@ -0,0 +1,86 @@
+import { o as git, s as parseGitStatus } from "./clone-DgXhqC05.mjs";
+import { existsSync } from "node:fs";
+
+//#region src/git/operations.ts
+function getGitStatus(dir) {
+	if (!existsSync(dir)) return void 0;
+	try {
+		git(["rev-parse", "--is-inside-work-tree"], { cwd: dir });
+		const parsed = parseGitStatus(git([
+			"status",
+			"--porcelain=v2",
+			"--branch"
+		], { cwd: dir }));
+		return {
+			isRepo: true,
+			branch: parsed.branch,
+			ahead: parsed.ahead,
+			behind: parsed.behind,
+			staged: parsed.staged,
+			modified: parsed.modified,
+			untracked: parsed.untracked,
+			hasChanges: parsed.staged.length > 0 || parsed.modified.length > 0 || parsed.untracked.length > 0
+		};
+	} catch {
+		return;
+	}
+}
+function getCurrentBranch(dir) {
+	try {
+		return git([
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], { cwd: dir });
+	} catch {
+		return;
+	}
+}
+function checkout(dir, ref) {
+	try {
+		git(["checkout", ref], { cwd: dir });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function pull(dir) {
+	try {
+		git(["pull"], { cwd: dir });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function fetch(dir, remote = "origin") {
+	try {
+		git(["fetch", remote], { cwd: dir });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getRemoteUrl(dir, remote = "origin") {
+	try {
+		return git([
+			"remote",
+			"get-url",
+			remote
+		], { cwd: dir });
+	} catch {
+		return;
+	}
+}
+function getLatestCommitHash(dir) {
+	try {
+		return git(["rev-parse", "HEAD"], { cwd: dir });
+	} catch {
+		return;
+	}
+}
+function hasUncommittedChanges(dir) {
+	return getGitStatus(dir)?.hasChanges ?? false;
+}
+
+//#endregion
+export { getLatestCommitHash as a, pull as c, getGitStatus as i, fetch as n, getRemoteUrl as o, getCurrentBranch as r, hasUncommittedChanges as s, checkout as t };

package/dist/hooks/index.d.mts

@@ -0,0 +1,3 @@
+import "../index-ucMWydcs.mjs";
+import { a as createHookable, i as createAgentHooks, n as AgentHooksInstance, r as Hookable, t as AgentHooks } from "../index-Csv1G0zj.mjs";
+export { AgentHooks, AgentHooksInstance, Hookable, createAgentHooks, createHookable as createHooks };

package/dist/hooks/index.mjs

@@ -0,0 +1,3 @@
+import { n as createHookable, t as createAgentHooks } from "../hooks-335rp9Cp.mjs";
+
+export { createAgentHooks, createHookable as createHooks };

package/dist/hooks-335rp9Cp.mjs

@@ -0,0 +1,9 @@
+import { createHooks as createHookable } from "hookable";
+
+//#region src/hooks/index.ts
+function createAgentHooks() {
+	return createHookable();
+}
+
+//#endregion
+export { createHookable as n, createAgentHooks as t };

package/dist/index-BZaywR9E.d.mts

@@ -0,0 +1,97 @@
+//#region src/skill/parse.d.ts
+interface SkillFrontmatter {
+  "name": string;
+  "description": string;
+  "license"?: string;
+  "compatibility"?: string;
+  "metadata"?: Record<string, string>;
+  "allowed-tools"?: string;
+  "globs"?: string | string[];
+  "alwaysApply"?: boolean;
+  "tags"?: string[];
+}
+interface ParsedSkill {
+  frontmatter: SkillFrontmatter;
+  content: string;
+  raw: string;
+}
+declare function parseSkillMd(content: string): ParsedSkill;
+declare function extractSkillName(frontmatter: SkillFrontmatter, filename?: string): string;
+/** @deprecated Use validateSkill from './validate' for spec-compliant validation */
+declare function validateSkillMd(parsed: ParsedSkill): string[];
+//#endregion
+//#region src/skill/discover.d.ts
+interface DiscoveredSkill {
+  path: string;
+  name: string;
+  parsed: ParsedSkill;
+}
+interface DiscoverOptions {
+  recursive?: boolean;
+}
+declare function discoverSkills(dir: string, options?: DiscoverOptions): DiscoveredSkill[];
+declare function filterSkills(skills: DiscoveredSkill[], query: string): DiscoveredSkill[];
+declare function findSkillByName(skills: DiscoveredSkill[], name: string): DiscoveredSkill | undefined;
+//#endregion
+//#region src/skill/install.d.ts
+interface InstallSkillOptions {
+  source: string;
+  skills?: string[];
+  agents?: string[];
+  global?: boolean;
+  cwd?: string;
+  mode?: "symlink" | "copy";
+}
+interface InstallSkillResultEntry {
+  skill: string;
+  agent: string;
+  path: string;
+}
+interface InstallSkillErrorEntry {
+  skill: string;
+  agent: string;
+  error: string;
+}
+interface InstallSkillResult {
+  success: boolean;
+  installed: InstallSkillResultEntry[];
+  errors: InstallSkillErrorEntry[];
+}
+declare function installSkill(options: InstallSkillOptions): Promise<InstallSkillResult>;
+//#endregion
+//#region src/skill/prompt.d.ts
+declare function toPromptXml(skills: DiscoveredSkill[]): string;
+//#endregion
+//#region src/skill/uninstall.d.ts
+interface UninstallSkillOptions {
+  skill: string;
+  agents?: string[];
+  global?: boolean;
+  cwd?: string;
+}
+interface UninstallSkillResultEntry {
+  skill: string;
+  agent: string;
+  path: string;
+}
+interface UninstallSkillErrorEntry {
+  skill: string;
+  agent: string;
+  error: string;
+}
+interface UninstallSkillResult {
+  success: boolean;
+  removed: UninstallSkillResultEntry[];
+  errors: UninstallSkillErrorEntry[];
+}
+declare function uninstallSkill(options: UninstallSkillOptions): Promise<UninstallSkillResult>;
+//#endregion
+//#region src/skill/validate.d.ts
+interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+declare function validateSkill(skill: ParsedSkill, dirName?: string): ValidationResult;
+//#endregion
+export { validateSkillMd as C, parseSkillMd as S, filterSkills as _, UninstallSkillResult as a, SkillFrontmatter as b, toPromptXml as c, InstallSkillResult as d, InstallSkillResultEntry as f, discoverSkills as g, DiscoveredSkill as h, UninstallSkillOptions as i, InstallSkillErrorEntry as l, DiscoverOptions as m, validateSkill as n, UninstallSkillResultEntry as o, installSkill as p, UninstallSkillErrorEntry as r, uninstallSkill as s, ValidationResult as t, InstallSkillOptions as u, findSkillByName as v, extractSkillName as x, ParsedSkill as y };

package/dist/index-Bd1gSwMB.d.mts

@@ -0,0 +1,31 @@
+//#region src/context/index.d.ts
+interface TokenEstimateOptions {
+  charsPerToken?: number;
+}
+declare function estimateTokens(text: string, options?: TokenEstimateOptions): number;
+interface TruncateOptions {
+  maxTokens: number;
+  charsPerToken?: number;
+  suffix?: string;
+}
+declare function truncateToFit(content: string, options: TruncateOptions): string;
+interface ContextItem {
+  content: string;
+  priority?: number;
+  id?: string;
+}
+interface BuildContextOptions {
+  maxTokens: number;
+  charsPerToken?: number;
+  separator?: string;
+}
+interface BuildContextResult {
+  content: string;
+  tokens: number;
+  included: string[];
+  excluded: string[];
+}
+declare function buildContext(items: ContextItem[], options: BuildContextOptions): BuildContextResult;
+declare function splitByTokens(text: string, maxTokensPerChunk: number, options?: TokenEstimateOptions): string[];
+//#endregion
+export { TruncateOptions as a, splitByTokens as c, TokenEstimateOptions as i, truncateToFit as l, BuildContextResult as n, buildContext as o, ContextItem as r, estimateTokens as s, BuildContextOptions as t };

package/dist/index-Bd4x_1H9.d.mts

@@ -0,0 +1,33 @@
+//#region src/sandbox/index.d.ts
+type SandboxProvider = "vercel" | "cloudflare";
+type SandboxType = "docker" | "cloudflare" | "vercel" | "none";
+interface SandboxOptions {
+  provider: SandboxProvider;
+  runtime?: string;
+  timeout?: number;
+  memory?: number;
+  cpu?: number;
+}
+interface SandboxExecResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  code: number | null;
+}
+interface Sandbox {
+  id: string;
+  provider: SandboxProvider;
+  exec: (command: string, args: string[]) => Promise<SandboxExecResult>;
+  writeFile: (path: string, content: string) => Promise<void>;
+  readFile: (path: string) => Promise<string>;
+  stop: () => Promise<void>;
+}
+interface SandboxDetection {
+  type: SandboxType;
+  details?: Record<string, string>;
+}
+declare function detectSandbox(): SandboxDetection;
+declare function createSandbox(options: SandboxOptions): Promise<Sandbox>;
+declare function isSandboxAvailable(provider: SandboxProvider): boolean;
+//#endregion
+export { SandboxProvider as a, detectSandbox as c, SandboxOptions as i, isSandboxAvailable as l, SandboxDetection as n, SandboxType as o, SandboxExecResult as r, createSandbox as s, Sandbox as t };

package/dist/index-C0ulBa5T.d.mts

@@ -0,0 +1,21 @@
+//#region src/exec/index.d.ts
+interface ExecOptions {
+  cwd?: string;
+  timeout?: number;
+  maxOutput?: number;
+  env?: Record<string, string>;
+  stdin?: string;
+}
+interface ExecResult {
+  ok: boolean;
+  code: number | null;
+  stdout: string;
+  stderr: string;
+  signal: string | null;
+  truncated: boolean;
+  timedOut: boolean;
+}
+declare function execSafe(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
+declare function execSafeSync(command: string, args: string[], options?: Omit<ExecOptions, "stdin">): ExecResult;
+//#endregion
+export { execSafeSync as i, ExecResult as n, execSafe as r, ExecOptions as t };

package/dist/{index-DwU61LUW.d.ts → index-C55JaUgw.d.mts}

@@ -15,8 +15,8 @@ interface CloneResult {
   path: string;
   error?: string;
 }
-declare function cloneRepo(url: string, dest: string, options?: CloneOptions): Promise<CloneResult>;
-declare function cloneToTemp(url: string, options?: CloneOptions): Promise<CloneResult>;
+declare function cloneRepo(url: string, dest: string, options?: CloneOptions): CloneResult;
+declare function cloneToTemp(url: string, options?: CloneOptions): CloneResult;
 declare function cleanupTempDir(path: string): boolean;
 declare function isTempDir(path: string): boolean;
 //#endregion
@@ -31,13 +31,13 @@ interface GitStatus {
   untracked: string[];
   hasChanges: boolean;
 }
-declare function getGitStatus(dir: string): Promise<GitStatus | undefined>;
-declare function getCurrentBranch(dir: string): Promise<string | undefined>;
-declare function checkout(dir: string, ref: string): Promise<boolean>;
-declare function pull(dir: string): Promise<boolean>;
-declare function fetch(dir: string, remote?: string): Promise<boolean>;
-declare function getRemoteUrl(dir: string, remote?: string): Promise<string | undefined>;
-declare function getLatestCommitHash(dir: string): Promise<string | undefined>;
-declare function hasUncommittedChanges(dir: string): Promise<boolean>;
+declare function getGitStatus(dir: string): GitStatus | undefined;
+declare function getCurrentBranch(dir: string): string | undefined;
+declare function checkout(dir: string, ref: string): boolean;
+declare function pull(dir: string): boolean;
+declare function fetch(dir: string, remote?: string): boolean;
+declare function getRemoteUrl(dir: string, remote?: string): string | undefined;
+declare function getLatestCommitHash(dir: string): string | undefined;
+declare function hasUncommittedChanges(dir: string): boolean;
 //#endregion
 export { getGitStatus as a, hasUncommittedChanges as c, CloneResult as d, GitCloneError as f, isTempDir as g, cloneToTemp as h, getCurrentBranch as i, pull as l, cloneRepo as m, checkout as n, getLatestCommitHash as o, cleanupTempDir as p, fetch as r, getRemoteUrl as s, GitStatus as t, CloneOptions as u };

package/dist/index-Csv1G0zj.d.mts

@@ -0,0 +1,36 @@
+import { r as UsageInfo } from "./index-ucMWydcs.mjs";
+import { Hookable, createHooks as createHookable } from "hookable";
+
+//#region src/hooks/index.d.ts
+interface AgentHooks {
+  "tool:before": (payload: {
+    name: string;
+    args: unknown;
+  }) => void | Promise<void>;
+  "tool:after": (payload: {
+    name: string;
+    args: unknown;
+    result: unknown;
+  }) => void | Promise<void>;
+  "tool:error": (payload: {
+    name: string;
+    error: Error;
+  }) => void | Promise<void>;
+  "llm:before": (payload: {
+    messages: unknown[];
+  }) => void | Promise<void>;
+  "llm:after": (payload: {
+    response: unknown;
+    usage?: UsageInfo;
+  }) => void | Promise<void>;
+  "iteration:start": (payload: {
+    iteration: number;
+  }) => void | Promise<void>;
+  "iteration:end": (payload: {
+    iteration: number;
+  }) => void | Promise<void>;
+}
+type AgentHooksInstance = Hookable<AgentHooks>;
+declare function createAgentHooks(): AgentHooksInstance;
+//#endregion
+export { createHookable as a, createAgentHooks as i, AgentHooksInstance as n, Hookable as r, AgentHooks as t };

package/dist/index-CvCCCs-_.d.mts

@@ -0,0 +1,20 @@
+//#region src/registry/index.d.ts
+interface Provider<T, Input = unknown> {
+  id: string;
+  match: (input: Input) => boolean;
+  resolve: (input: Input) => Promise<T> | T;
+  priority?: number;
+}
+interface Registry<T, Input = unknown> {
+  register: (provider: Provider<T, Input>) => void;
+  unregister: (id: string) => boolean;
+  resolve: (input: Input) => Promise<T | undefined>;
+  list: () => Provider<T, Input>[];
+}
+interface RegistryOptions {
+  defaultPriority?: number;
+}
+declare function createRegistry<T, Input = unknown>(options?: RegistryOptions): Registry<T, Input>;
+declare function defineProvider<T, Input = unknown>(provider: Provider<T, Input>): Provider<T, Input>;
+//#endregion
+export { defineProvider as a, createRegistry as i, Registry as n, RegistryOptions as r, Provider as t };

package/dist/{index-LzafUiEo.d.ts → index-Cy8LThTV.d.mts}

@@ -3,7 +3,7 @@ declare function computeContentHash(content: string): string;
 declare function computeFileHash(filePath: string): string | undefined;
 declare function computeDirectoryHash(dirPath: string, exclude?: string[]): string | undefined;
 //#endregion
-//#region src/lock/lock.d.ts
+//#region src/lock/index.d.ts
 interface SkillLockEntry {
   name: string;
   source: string;

package/dist/index-D5A0wwzb.d.mts

@@ -0,0 +1,55 @@
+import { r as UsageInfo } from "./index-ucMWydcs.mjs";
+
+//#region src/stream/index.d.ts
+type StreamPart = {
+  type: "text";
+  data: string;
+} | {
+  type: "tool_call";
+  data: {
+    name: string;
+    args: unknown;
+  };
+} | {
+  type: "tool_result";
+  data: {
+    name: string;
+    result: unknown;
+  };
+} | {
+  type: "usage";
+  data: UsageInfo;
+} | {
+  type: "error";
+  data: Error;
+} | {
+  type: "done";
+  data: null;
+};
+interface StreamResult<T> {
+  readonly value: Promise<T>;
+  readonly stream: AsyncIterable<StreamPart>;
+  toResponse: () => Response;
+  toSSEResponse: () => Response;
+  consumeStream: () => Promise<void>;
+}
+interface StreamResultOptions<T> {
+  stream: AsyncIterable<StreamPart>;
+  getValue: () => Promise<T>;
+}
+declare function createStreamResult<T>(options: StreamResultOptions<T>): StreamResult<T>;
+declare function formatSSE(event: string, data: unknown): string;
+declare function parseSSE(line: string): {
+  event?: string;
+  data?: string;
+} | null;
+declare class SSEParser {
+  private currentEvent;
+  private dataBuffer;
+  parse(chunk: string): Array<{
+    event?: string;
+    data: unknown;
+  }>;
+}
+//#endregion
+export { createStreamResult as a, StreamResultOptions as i, StreamPart as n, formatSSE as o, StreamResult as r, parseSSE as s, SSEParser as t };

package/dist/index-DFqD_DAh.d.mts

@@ -0,0 +1,80 @@
+//#region src/fs/index.d.ts
+interface FileStat {
+  size: number;
+  isFile: boolean;
+  isDirectory: boolean;
+  mtime?: Date;
+}
+interface VirtualFS {
+  readFile: (path: string) => Promise<string>;
+  writeFile: (path: string, content: string) => Promise<void>;
+  exists: (path: string) => Promise<boolean>;
+  readdir: (path: string) => Promise<string[]>;
+  mkdir: (path: string, options?: {
+    recursive?: boolean;
+  }) => Promise<void>;
+  rm: (path: string, options?: {
+    recursive?: boolean;
+  }) => Promise<void>;
+  stat: (path: string) => Promise<FileStat>;
+}
+declare class InMemoryFS implements VirtualFS {
+  private files;
+  private dirs;
+  private normalizePath;
+  readFile(path: string): Promise<string>;
+  writeFile(path: string, content: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  readdir(path: string): Promise<string[]>;
+  mkdir(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+  rm(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+  stat(path: string): Promise<FileStat>;
+}
+declare class OverlayFS implements VirtualFS {
+  private base;
+  private overlay;
+  private deleted;
+  constructor(base: VirtualFS);
+  private normalizePath;
+  readFile(path: string): Promise<string>;
+  writeFile(path: string, content: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  readdir(path: string): Promise<string[]>;
+  mkdir(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+  rm(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+  stat(path: string): Promise<FileStat>;
+}
+declare class RealFS implements VirtualFS {
+  private basePath;
+  private normalizedBase;
+  constructor(basePath?: string);
+  private resolve;
+  readFile(path: string): Promise<string>;
+  writeFile(path: string, content: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  readdir(path: string): Promise<string[]>;
+  mkdir(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+  rm(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+  stat(path: string): Promise<FileStat>;
+}
+interface Storage {
+  getItem: (key: string) => Promise<string | null> | string | null;
+  setItem: (key: string, value: string) => Promise<void> | void;
+  removeItem: (key: string) => Promise<void> | void;
+  getKeys: (base?: string) => Promise<string[]> | string[];
+}
+declare function createFSFromStorage(storage: Storage): VirtualFS;
+//#endregion
+export { Storage as a, RealFS as i, InMemoryFS as n, VirtualFS as o, OverlayFS as r, createFSFromStorage as s, FileStat as t };

package/dist/index-DShEKmmL.d.mts

@@ -0,0 +1,43 @@
+//#region src/tool/index.d.ts
+interface ToolParameter {
+  type: "string" | "number" | "boolean" | "array" | "object";
+  description?: string;
+  required?: boolean;
+  enum?: (string | number | boolean)[];
+  items?: ToolParameter;
+  properties?: Record<string, ToolParameter>;
+  default?: unknown;
+}
+interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters?: Record<string, ToolParameter>;
+}
+interface JSONSchema {
+  type: "object";
+  properties: Record<string, JSONSchemaProperty>;
+  required?: string[];
+  additionalProperties?: boolean;
+}
+interface JSONSchemaProperty {
+  type: string | string[];
+  description?: string;
+  enum?: (string | number | boolean)[];
+  items?: JSONSchemaProperty;
+  properties?: Record<string, JSONSchemaProperty>;
+  required?: string[];
+  default?: unknown;
+}
+declare function defineTool<T extends ToolDefinition>(tool: T): T;
+declare function toolToSchema(tool: ToolDefinition): {
+  name: string;
+  description: string;
+  input_schema: JSONSchema;
+};
+declare function toolsToSchema(tools: ToolDefinition[]): {
+  name: string;
+  description: string;
+  input_schema: JSONSchema;
+}[];
+//#endregion
+export { defineTool as a, ToolParameter as i, JSONSchemaProperty as n, toolToSchema as o, ToolDefinition as r, toolsToSchema as s, JSONSchema as t };

package/dist/index-DpFup4kC.d.mts

@@ -0,0 +1,21 @@
+import { r as UsageInfo, t as CostRates } from "./index-ucMWydcs.mjs";
+
+//#region src/stop/index.d.ts
+type StopCondition<Ctx> = (ctx: Ctx) => boolean | Promise<boolean>;
+declare function iterationCountIs(max: number): StopCondition<{
+  iteration: number;
+}>;
+declare function tokenCountIs(max: number): StopCondition<{
+  usage?: UsageInfo;
+}>;
+declare function costIs(maxDollars: number, rates: CostRates): StopCondition<{
+  usage?: UsageInfo;
+}>;
+declare function timeout(ms: number): StopCondition<{
+  startTime: number;
+}>;
+declare function and<Ctx>(...conditions: StopCondition<Ctx>[]): StopCondition<Ctx>;
+declare function or<Ctx>(...conditions: StopCondition<Ctx>[]): StopCondition<Ctx>;
+declare function not<Ctx>(condition: StopCondition<Ctx>): StopCondition<Ctx>;
+//#endregion
+export { not as a, tokenCountIs as c, iterationCountIs as i, and as n, or as o, costIs as r, timeout as s, StopCondition as t };

package/dist/index-ucMWydcs.d.mts

@@ -0,0 +1,19 @@
+//#region src/usage/index.d.ts
+interface UsageInfo {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+}
+interface CostRates {
+  inputCostPerMillionTokens: number;
+  outputCostPerMillionTokens: number;
+  cacheReadCostPerMillionTokens?: number;
+  cacheWriteCostPerMillionTokens?: number;
+}
+declare function calculateCost(usage: UsageInfo, rates: CostRates): number;
+declare function aggregateUsage(...usages: UsageInfo[]): UsageInfo;
+declare const MODEL_PRICING: Record<string, CostRates>;
+declare function getRatesForModel(modelId: string): CostRates | undefined;
+//#endregion
+export { calculateCost as a, aggregateUsage as i, MODEL_PRICING as n, getRatesForModel as o, UsageInfo as r, CostRates as t };

package/dist/index.d.mts

@@ -0,0 +1,18 @@
+import { a as TruncateOptions, c as splitByTokens, i as TokenEstimateOptions, l as truncateToFit, n as BuildContextResult, o as buildContext, r as ContextItem, s as estimateTokens, t as BuildContextOptions } from "./index-Bd1gSwMB.mjs";
+import { _ as getAgentConfig, a as getAgentSkillsDir, c as isCI, d as detectAgentByEnv, f as detectCurrentAgent, g as agents, h as AgentConfig, i as getAgentRulesPath, l as isTTY, m as isRunningInAgent, n as agentConfigExists, o as getXDGPaths, p as detectInstalledAgents, r as getAgentConfigDir, s as hasTTY, t as XDGPaths, u as DetectedAgent, v as getAgentIds, y as getAllAgents } from "./index-CzgY9GU2.mjs";
+import { i as execSafeSync, n as ExecResult, r as execSafe, t as ExecOptions } from "./index-C0ulBa5T.mjs";
+import { a as Storage, i as RealFS, n as InMemoryFS, o as VirtualFS, r as OverlayFS, s as createFSFromStorage, t as FileStat } from "./index-DFqD_DAh.mjs";
+import { a as getGitStatus, c as hasUncommittedChanges, d as CloneResult, f as GitCloneError, g as isTempDir, h as cloneToTemp, i as getCurrentBranch, l as pull, m as cloneRepo, n as checkout, o as getLatestCommitHash, p as cleanupTempDir, r as fetch, s as getRemoteUrl, t as GitStatus, u as CloneOptions } from "./index-C55JaUgw.mjs";
+import { a as calculateCost, i as aggregateUsage, n as MODEL_PRICING, o as getRatesForModel, r as UsageInfo, t as CostRates } from "./index-ucMWydcs.mjs";
+import { a as createHookable, i as createAgentHooks, n as AgentHooksInstance, r as Hookable, t as AgentHooks } from "./index-Csv1G0zj.mjs";
+import { a as removeSymlink, c as validateSymlinkTarget, d as copyDirectory, f as copyFile, i as isSymlink, l as CopyOptions, n as SymlinkResult, o as isPathSafe, p as getDirectorySize, r as createSymlink, s as sanitizeName, t as SymlinkOptions, u as CopyResult } from "./index-DPt7J0hF.mjs";
+import { a as getSkillFromLock, c as listSkillsInLock, d as writeSkillLock, f as computeContentHash, i as createEmptyLock, l as readSkillLock, m as computeFileHash, n as SkillLockEntry, o as hasSkillInLock, p as computeDirectoryHash, r as addSkillToLock, s as isSkillOutdated, t as SkillLock, u as removeSkillFromLock } from "./index-Cy8LThTV.mjs";
+import { a as defineProvider, i as createRegistry, n as Registry, r as RegistryOptions, t as Provider } from "./index-CvCCCs-_.mjs";
+import { a as SandboxProvider, c as detectSandbox, i as SandboxOptions, l as isSandboxAvailable, n as SandboxDetection, o as SandboxType, r as SandboxExecResult, s as createSandbox, t as Sandbox } from "./index-Bd4x_1H9.mjs";
+import { C as validateSkillMd, S as parseSkillMd, _ as filterSkills, a as UninstallSkillResult, b as SkillFrontmatter, c as toPromptXml, d as InstallSkillResult, f as InstallSkillResultEntry, g as discoverSkills, h as DiscoveredSkill, i as UninstallSkillOptions, l as InstallSkillErrorEntry, m as DiscoverOptions, n as validateSkill, o as UninstallSkillResultEntry, p as installSkill, r as UninstallSkillErrorEntry, s as uninstallSkill, t as ValidationResult, u as InstallSkillOptions, v as findSkillByName, x as extractSkillName, y as ParsedSkill } from "./index-BZaywR9E.mjs";
+import { a as parseOwnerRepo, c as SourceProvider, d as getProviderFromUrl, f as parseGitHubUrl, i as isUrl, l as buildGitHubCloneUrl, n as getOwnerRepo, o as parseSource, p as parseGitLabUrl, r as isLocalPath, s as ProviderInfo, t as ParsedSource, u as buildGitLabCloneUrl } from "./index-wTumcHrH.mjs";
+import { a as not, c as tokenCountIs, i as iterationCountIs, n as and, o as or, r as costIs, s as timeout, t as StopCondition } from "./index-DpFup4kC.mjs";
+import { a as createStreamResult, i as StreamResultOptions, n as StreamPart, o as formatSSE, r as StreamResult, s as parseSSE, t as SSEParser } from "./index-D5A0wwzb.mjs";
+import { a as defineTool, i as ToolParameter, n as JSONSchemaProperty, o as toolToSchema, r as ToolDefinition, s as toolsToSchema, t as JSONSchema } from "./index-DShEKmmL.mjs";
+import { a as truncate, c as bold, d as gray, f as green, h as yellow, i as pluralize, l as cyan, m as stripAnsi, n as shortenPath, o as ANSI, p as red, r as formatList, s as blue, t as expandPath, u as dim } from "./index-CbYchDwg.mjs";
+export { ANSI, AgentConfig, AgentHooks, AgentHooksInstance, BuildContextOptions, BuildContextResult, CloneOptions, CloneResult, ContextItem, CopyOptions, CopyResult, CostRates, DetectedAgent, DiscoverOptions, DiscoveredSkill, ExecOptions, ExecResult, FileStat, GitCloneError, GitStatus, Hookable, InMemoryFS, InstallSkillErrorEntry, InstallSkillOptions, InstallSkillResult, InstallSkillResultEntry, JSONSchema, JSONSchemaProperty, MODEL_PRICING, OverlayFS, ParsedSkill, ParsedSource, Provider, ProviderInfo, RealFS, Registry, RegistryOptions, SSEParser, Sandbox, SandboxDetection, SandboxExecResult, SandboxOptions, SandboxProvider, SandboxType, SkillFrontmatter, SkillLock, SkillLockEntry, SourceProvider, StopCondition, Storage, StreamPart, StreamResult, StreamResultOptions, SymlinkOptions, SymlinkResult, TokenEstimateOptions, ToolDefinition, ToolParameter, TruncateOptions, UninstallSkillErrorEntry, UninstallSkillOptions, UninstallSkillResult, UninstallSkillResultEntry, UsageInfo, ValidationResult, VirtualFS, XDGPaths, addSkillToLock, agentConfigExists, agents, aggregateUsage, and, blue, bold, buildContext, buildGitHubCloneUrl, buildGitLabCloneUrl, calculateCost, checkout, cleanupTempDir, cloneRepo, cloneToTemp, computeContentHash, computeDirectoryHash, computeFileHash, copyDirectory, copyFile, costIs, createAgentHooks, createEmptyLock, createFSFromStorage, createHookable as createHooks, createRegistry, createSandbox, createStreamResult, createSymlink, cyan, defineProvider, defineTool, detectAgentByEnv, detectCurrentAgent, detectInstalledAgents, detectSandbox, dim, discoverSkills, estimateTokens, execSafe, execSafeSync, expandPath, extractSkillName, fetch, filterSkills, findSkillByName, formatList, formatSSE, getAgentConfig, getAgentConfigDir, getAgentIds, getAgentRulesPath, getAgentSkillsDir, getAllAgents, getCurrentBranch, getDirectorySize, getGitStatus, getLatestCommitHash, getOwnerRepo, getProviderFromUrl, getRatesForModel, getRemoteUrl, getSkillFromLock, getXDGPaths, gray, green, hasSkillInLock, hasTTY, hasUncommittedChanges, installSkill, isCI, isLocalPath, isPathSafe, isRunningInAgent, isSandboxAvailable, isSkillOutdated, isSymlink, isTTY, isTempDir, isUrl, iterationCountIs, listSkillsInLock, not, or, parseGitHubUrl, parseGitLabUrl, parseOwnerRepo, parseSSE, parseSkillMd, parseSource, pluralize, pull, readSkillLock, red, removeSkillFromLock, removeSymlink, sanitizeName, shortenPath, splitByTokens, stripAnsi, timeout, toPromptXml, tokenCountIs, toolToSchema, toolsToSchema, truncate, truncateToFit, uninstallSkill, validateSkill, validateSkillMd, validateSymlinkTarget, writeSkillLock, yellow };