unagent 0.0.1

package/dist/env/index.d.ts

@@ -0,0 +1,2 @@
+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-BW91Ai1Y.js";
+export { AgentConfig, DetectedAgent, XDGPaths, agentConfigExists, agents, detectAgentByEnv, detectCurrentAgent, detectInstalledAgents, getAgentConfig, getAgentConfigDir, getAgentIds, getAgentRulesPath, getAgentSkillsDir, getAllAgents, getXDGPaths, hasTTY, isCI, isRunningInAgent, isTTY };

package/dist/env/index.js

@@ -0,0 +1,4 @@
+import { a as agentConfigExists, c as getAgentSkillsDir, d as isCI, f as isTTY, g as getAllAgents, h as getAgentIds, i as isRunningInAgent, l as getXDGPaths, m as getAgentConfig, n as detectCurrentAgent, o as getAgentConfigDir, p as agents, r as detectInstalledAgents, s as getAgentRulesPath, t as detectAgentByEnv, u as hasTTY } from "../env-BUegcU7a.js";
+import "../path-nPuHl-f5.js";
+
+export { agentConfigExists, agents, detectAgentByEnv, detectCurrentAgent, detectInstalledAgents, getAgentConfig, getAgentConfigDir, getAgentIds, getAgentRulesPath, getAgentSkillsDir, getAllAgents, getXDGPaths, hasTTY, isCI, isRunningInAgent, isTTY };

package/dist/env-BUegcU7a.js

@@ -0,0 +1,392 @@
+import { t as expandPath } from "./path-nPuHl-f5.js";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "pathe";
+import { hasTTY, isCI } from "std-env";
+
+//#region src/env/agents.ts
+const agents = {
+	"claude-code": {
+		name: "Claude Code",
+		configDir: "~/.claude",
+		rulesFile: "CLAUDE.md",
+		skillsDir: "skills",
+		envDetect: ["CLAUDE_CODE", "CLAUDE_CODE_ENTRY"],
+		description: "Anthropic's official CLI for Claude"
+	},
+	"cursor": {
+		name: "Cursor",
+		configDir: "~/.cursor",
+		rulesFile: ".cursorrules",
+		skillsDir: "rules",
+		envDetect: ["CURSOR_SESSION_ID"],
+		description: "AI-powered code editor"
+	},
+	"windsurf": {
+		name: "Windsurf",
+		configDir: "~/.codeium/windsurf",
+		rulesFile: ".windsurfrules",
+		skillsDir: "rules",
+		envDetect: ["WINDSURF_SESSION_ID"],
+		description: "Codeium's AI code editor"
+	},
+	"cline": {
+		name: "Cline",
+		configDir: "~/.cline",
+		rulesFile: ".clinerules",
+		skillsDir: "rules",
+		envDetect: ["CLINE_TASK"],
+		description: "VS Code extension for Claude"
+	},
+	"aider": {
+		name: "Aider",
+		configDir: "~/.aider",
+		rulesFile: ".aider.conf.yml",
+		envDetect: ["AIDER_MODEL"],
+		description: "AI pair programming in terminal"
+	},
+	"continue": {
+		name: "Continue",
+		configDir: "~/.continue",
+		rulesFile: "config.json",
+		skillsDir: "rules",
+		envDetect: ["CONTINUE_GLOBAL_DIR"],
+		description: "Open-source AI code assistant"
+	},
+	"copilot": {
+		name: "GitHub Copilot",
+		configDir: "~/.config/github-copilot",
+		envDetect: ["GITHUB_COPILOT_TOKEN"],
+		description: "GitHub's AI pair programmer"
+	},
+	"codex": {
+		name: "OpenAI Codex CLI",
+		configDir: "~/.codex",
+		rulesFile: "instructions.md",
+		envDetect: ["CODEX_HOME"],
+		description: "OpenAI's Codex CLI"
+	},
+	"zed": {
+		name: "Zed",
+		configDir: "~/.config/zed",
+		rulesFile: "settings.json",
+		envDetect: ["ZED_IMPERSONATE"],
+		description: "High-performance code editor with AI"
+	},
+	"void": {
+		name: "Void",
+		configDir: "~/.void",
+		rulesFile: ".voidrules",
+		envDetect: ["VOID_EDITOR"],
+		description: "Open-source Cursor alternative"
+	},
+	"amp": {
+		name: "Amp",
+		configDir: "~/.amp",
+		rulesFile: "amp.md",
+		skillsDir: "skills",
+		envDetect: ["AMP_SESSION"],
+		description: "Sourcegraph's AI coding agent"
+	},
+	"roo": {
+		name: "Roo Code",
+		configDir: "~/.roo",
+		rulesFile: ".roorules",
+		skillsDir: "rules",
+		envDetect: ["ROO_CODE"],
+		description: "AI coding assistant"
+	},
+	"avante": {
+		name: "Avante",
+		configDir: "~/.config/nvim",
+		rulesFile: "avante.lua",
+		envDetect: ["AVANTE_PROVIDER"],
+		description: "Neovim AI plugin"
+	},
+	"codestory": {
+		name: "CodeStory",
+		configDir: "~/.codestory",
+		rulesFile: ".codestoryrules",
+		envDetect: ["CODESTORY_SESSION"],
+		description: "AI-powered code editor"
+	},
+	"gpt-engineer": {
+		name: "GPT Engineer",
+		configDir: "~/.gpt-engineer",
+		rulesFile: "prompt",
+		envDetect: ["GPTE_API_KEY"],
+		description: "AI code generation"
+	},
+	"sweep": {
+		name: "Sweep",
+		configDir: "~/.sweep",
+		rulesFile: "sweep.yaml",
+		envDetect: ["SWEEP_API_KEY"],
+		description: "AI junior developer"
+	},
+	"mentat": {
+		name: "Mentat",
+		configDir: "~/.mentat",
+		rulesFile: ".mentat_config.json",
+		envDetect: ["MENTAT_API_KEY"],
+		description: "AI coding assistant"
+	},
+	"goose": {
+		name: "Goose",
+		configDir: "~/.config/goose",
+		rulesFile: "config.yaml",
+		envDetect: ["GOOSE_PROVIDER"],
+		description: "Block's AI agent"
+	},
+	"supermaven": {
+		name: "Supermaven",
+		configDir: "~/.supermaven",
+		envDetect: ["SUPERMAVEN_API_KEY"],
+		description: "Fast AI code completion"
+	},
+	"tabnine": {
+		name: "Tabnine",
+		configDir: "~/.tabnine",
+		envDetect: ["TABNINE_API_KEY"],
+		description: "AI code completion"
+	},
+	"codeium": {
+		name: "Codeium",
+		configDir: "~/.codeium",
+		envDetect: ["CODEIUM_API_KEY"],
+		description: "Free AI code completion"
+	},
+	"sourcegraph-cody": {
+		name: "Sourcegraph Cody",
+		configDir: "~/.sourcegraph",
+		rulesFile: "cody.json",
+		envDetect: ["SRC_ACCESS_TOKEN"],
+		description: "Sourcegraph's AI assistant"
+	},
+	"amazon-q": {
+		name: "Amazon Q",
+		configDir: "~/.aws/amazonq",
+		envDetect: ["AMAZON_Q_TOKEN"],
+		description: "AWS AI assistant"
+	},
+	"gemini-code-assist": {
+		name: "Gemini Code Assist",
+		configDir: "~/.config/google-cloud",
+		envDetect: ["GOOGLE_APPLICATION_CREDENTIALS"],
+		description: "Google's AI coding assistant"
+	},
+	"replit-agent": {
+		name: "Replit Agent",
+		configDir: "~/.replit",
+		rulesFile: ".replit",
+		envDetect: ["REPL_ID"],
+		description: "Replit's AI agent"
+	},
+	"devin": {
+		name: "Devin",
+		configDir: "~/.devin",
+		envDetect: ["DEVIN_API_KEY"],
+		description: "Cognition's AI software engineer"
+	},
+	"bolt": {
+		name: "Bolt",
+		configDir: "~/.bolt",
+		envDetect: ["BOLT_API_KEY"],
+		description: "StackBlitz AI"
+	},
+	"v0": {
+		name: "v0",
+		configDir: "~/.v0",
+		envDetect: ["V0_API_KEY"],
+		description: "Vercel's AI UI generator"
+	},
+	"lovable": {
+		name: "Lovable",
+		configDir: "~/.lovable",
+		envDetect: ["LOVABLE_API_KEY"],
+		description: "AI full-stack developer"
+	},
+	"pythagora": {
+		name: "Pythagora",
+		configDir: "~/.pythagora",
+		rulesFile: "prompts.json",
+		envDetect: ["PYTHAGORA_API_KEY"],
+		description: "AI developer"
+	},
+	"smol-developer": {
+		name: "Smol Developer",
+		configDir: "~/.smol",
+		rulesFile: "prompt.md",
+		envDetect: ["SMOL_AI_KEY"],
+		description: "AI junior developer"
+	},
+	"plandex": {
+		name: "Plandex",
+		configDir: "~/.plandex",
+		rulesFile: "plandex.yaml",
+		envDetect: ["PLANDEX_API_KEY"],
+		description: "AI coding agent for complex tasks"
+	},
+	"auto-gpt": {
+		name: "Auto-GPT",
+		configDir: "~/.auto-gpt",
+		rulesFile: "ai_settings.yaml",
+		envDetect: ["AUTO_GPT_KEY"],
+		description: "Autonomous GPT-4 agent"
+	},
+	"agent-gpt": {
+		name: "AgentGPT",
+		configDir: "~/.agent-gpt",
+		envDetect: ["AGENT_GPT_KEY"],
+		description: "Browser-based AI agent"
+	},
+	"babyagi": {
+		name: "BabyAGI",
+		configDir: "~/.babyagi",
+		envDetect: ["BABY_AGI_KEY"],
+		description: "Task-driven AI agent"
+	},
+	"langchain-agent": {
+		name: "LangChain Agent",
+		configDir: "~/.langchain",
+		envDetect: ["LANGCHAIN_API_KEY"],
+		description: "LangChain-based agents"
+	},
+	"crewai": {
+		name: "CrewAI",
+		configDir: "~/.crewai",
+		rulesFile: "agents.yaml",
+		envDetect: ["CREWAI_API_KEY"],
+		description: "Multi-agent orchestration"
+	},
+	"autogen": {
+		name: "AutoGen",
+		configDir: "~/.autogen",
+		rulesFile: "OAI_CONFIG_LIST",
+		envDetect: ["AUTOGEN_USE_DOCKER"],
+		description: "Microsoft's multi-agent framework"
+	},
+	"chatdev": {
+		name: "ChatDev",
+		configDir: "~/.chatdev",
+		rulesFile: "config.yaml",
+		envDetect: ["CHATDEV_KEY"],
+		description: "AI software company"
+	},
+	"metagpt": {
+		name: "MetaGPT",
+		configDir: "~/.metagpt",
+		rulesFile: "config2.yaml",
+		envDetect: ["METAGPT_KEY"],
+		description: "Multi-agent software company"
+	},
+	"superagi": {
+		name: "SuperAGI",
+		configDir: "~/.superagi",
+		envDetect: ["SUPERAGI_KEY"],
+		description: "Open-source AGI framework"
+	},
+	"jarvis": {
+		name: "Jarvis",
+		configDir: "~/.jarvis",
+		envDetect: ["JARVIS_API_KEY"],
+		description: "AI assistant"
+	},
+	"claude-engineer": {
+		name: "Claude Engineer",
+		configDir: "~/.claude-engineer",
+		rulesFile: "system_prompt.txt",
+		envDetect: ["CLAUDE_ENGINEER"],
+		description: "Claude-based coding assistant"
+	},
+	"codegeex": {
+		name: "CodeGeeX",
+		configDir: "~/.codegeex",
+		envDetect: ["CODEGEEX_API_KEY"],
+		description: "AI code assistant"
+	},
+	"safurai": {
+		name: "Safurai",
+		configDir: "~/.safurai",
+		envDetect: ["SAFURAI_API_KEY"],
+		description: "AI code assistant"
+	},
+	"codegpt": {
+		name: "CodeGPT",
+		configDir: "~/.codegpt",
+		envDetect: ["CODEGPT_API_KEY"],
+		description: "VS Code AI extension"
+	}
+};
+function getAgentConfig(agentId) {
+	return agents[agentId];
+}
+function getAgentIds() {
+	return Object.keys(agents);
+}
+function getAllAgents() {
+	return Object.values(agents);
+}
+
+//#endregion
+//#region src/env/paths.ts
+function getXDGPaths() {
+	const home = homedir();
+	return {
+		data: process.env.XDG_DATA_HOME || join(home, ".local", "share"),
+		config: process.env.XDG_CONFIG_HOME || join(home, ".config"),
+		cache: process.env.XDG_CACHE_HOME || join(home, ".cache"),
+		state: process.env.XDG_STATE_HOME || join(home, ".local", "state")
+	};
+}
+function getAgentConfigDir(agent) {
+	return expandPath(agent.configDir);
+}
+function getAgentRulesPath(agent) {
+	if (!agent.rulesFile) return void 0;
+	return join(getAgentConfigDir(agent), agent.rulesFile);
+}
+function getAgentSkillsDir(agent) {
+	if (!agent.skillsDir) return void 0;
+	return join(getAgentConfigDir(agent), agent.skillsDir);
+}
+function agentConfigExists(agent) {
+	return existsSync(getAgentConfigDir(agent));
+}
+/** @deprecated Use `hasTTY` from std-env instead */
+const isTTY = hasTTY;
+
+//#endregion
+//#region src/env/detect.ts
+function detectAgentByEnv(agent) {
+	if (!agent.envDetect) return false;
+	return agent.envDetect.some((envVar) => !!process.env[envVar]);
+}
+function detectCurrentAgent() {
+	for (const [id, config] of Object.entries(agents)) if (detectAgentByEnv(config)) return {
+		id,
+		config,
+		detected: agentConfigExists(config) ? "both" : "env"
+	};
+}
+function detectInstalledAgents() {
+	const detected = [];
+	for (const [id, config] of Object.entries(agents)) {
+		const envDetected = detectAgentByEnv(config);
+		const configExists = agentConfigExists(config);
+		if (envDetected || configExists) detected.push({
+			id,
+			config,
+			detected: envDetected && configExists ? "both" : envDetected ? "env" : "config"
+		});
+	}
+	return detected;
+}
+function isRunningInAgent(agentId) {
+	const config = getAgentConfig(agentId);
+	if (!config) return false;
+	return detectAgentByEnv(config);
+}
+
+//#endregion
+export { agentConfigExists as a, getAgentSkillsDir as c, isCI as d, isTTY as f, getAllAgents as g, getAgentIds as h, isRunningInAgent as i, getXDGPaths as l, getAgentConfig as m, detectCurrentAgent as n, getAgentConfigDir as o, agents as p, detectInstalledAgents as r, getAgentRulesPath as s, detectAgentByEnv as t, hasTTY as u };

package/dist/git/index.d.ts

@@ -0,0 +1,2 @@
+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-DwU61LUW.js";
+export { CloneOptions, CloneResult, GitCloneError, GitStatus, checkout, cleanupTempDir, cloneRepo, cloneToTemp, fetch, getCurrentBranch, getGitStatus, getLatestCommitHash, getRemoteUrl, hasUncommittedChanges, isTempDir, pull };

package/dist/git/index.js

@@ -0,0 +1,3 @@
+import { a as getLatestCommitHash, c as pull, d as cloneRepo, f as cloneToTemp, i as getGitStatus, l as GitCloneError, n as fetch, o as getRemoteUrl, p as isTempDir, r as getCurrentBranch, s as hasUncommittedChanges, t as checkout, u as cleanupTempDir } from "../git-D4ZclaF6.js";
+
+export { GitCloneError, checkout, cleanupTempDir, cloneRepo, cloneToTemp, fetch, getCurrentBranch, getGitStatus, getLatestCommitHash, getRemoteUrl, hasUncommittedChanges, isTempDir, pull };

package/dist/git-D4ZclaF6.js

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "pathe";
+import { simpleGit } from "simple-git";
+
+//#region src/git/clone.ts
+var GitCloneError = class extends Error {
+	url;
+	cause;
+	constructor(message, url, cause) {
+		super(message);
+		this.name = "GitCloneError";
+		this.url = url;
+		this.cause = cause;
+	}
+};
+async function cloneRepo(url, dest, options = {}) {
+	const { depth = 1, branch, timeout = 6e4 } = options;
+	try {
+		const git = simpleGit({ timeout: { block: timeout } });
+		const cloneOptions = [];
+		if (depth > 0) cloneOptions.push("--depth", String(depth));
+		if (branch) cloneOptions.push("--branch", branch);
+		const destDir = join(dest, "..");
+		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+		await git.clone(url, dest, cloneOptions);
+		return {
+			success: true,
+			path: dest
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: dest,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+async function cloneToTemp(url, options = {}) {
+	const { tempDir = tmpdir() } = options;
+	return cloneRepo(url, join(tempDir, `unagent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`), options);
+}
+function cleanupTempDir(path) {
+	const temp = tmpdir();
+	if (!path.startsWith(temp)) return false;
+	try {
+		if (existsSync(path)) rmSync(path, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isTempDir(path) {
+	return path.startsWith(tmpdir());
+}
+
+//#endregion
+//#region src/git/operations.ts
+async function getGitStatus(dir) {
+	if (!existsSync(dir)) return void 0;
+	try {
+		const git = simpleGit(dir);
+		if (!await git.checkIsRepo()) return void 0;
+		const status = await git.status();
+		return {
+			isRepo: true,
+			branch: status.current || "HEAD",
+			ahead: status.ahead,
+			behind: status.behind,
+			staged: status.staged,
+			modified: status.modified,
+			untracked: status.not_added,
+			hasChanges: !status.isClean()
+		};
+	} catch {
+		return;
+	}
+}
+async function getCurrentBranch(dir) {
+	try {
+		return (await simpleGit(dir).revparse(["--abbrev-ref", "HEAD"])).trim();
+	} catch {
+		return;
+	}
+}
+async function checkout(dir, ref) {
+	try {
+		await simpleGit(dir).checkout(ref);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function pull(dir) {
+	try {
+		await simpleGit(dir).pull();
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function fetch(dir, remote = "origin") {
+	try {
+		await simpleGit(dir).fetch(remote);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function getRemoteUrl(dir, remote = "origin") {
+	try {
+		return (await simpleGit(dir).getRemotes(true)).find((r) => r.name === remote)?.refs.fetch;
+	} catch {
+		return;
+	}
+}
+async function getLatestCommitHash(dir) {
+	try {
+		return (await simpleGit(dir).log({ maxCount: 1 })).latest?.hash;
+	} catch {
+		return;
+	}
+}
+async function hasUncommittedChanges(dir) {
+	return (await getGitStatus(dir))?.hasChanges ?? false;
+}
+
+//#endregion
+export { getLatestCommitHash as a, pull as c, cloneRepo as d, cloneToTemp as f, getGitStatus as i, GitCloneError as l, fetch as n, getRemoteUrl as o, isTempDir as p, getCurrentBranch as r, hasUncommittedChanges as s, checkout as t, cleanupTempDir as u };

package/dist/index-BW91Ai1Y.d.ts

@@ -0,0 +1,43 @@
+import { hasTTY, isCI } from "std-env";
+
+//#region src/env/agents.d.ts
+interface AgentConfig {
+  name: string;
+  configDir: string;
+  rulesFile?: string;
+  skillsDir?: string;
+  envDetect?: string[];
+  description?: string;
+}
+declare const agents: Record<string, AgentConfig>;
+declare function getAgentConfig(agentId: string): AgentConfig | undefined;
+declare function getAgentIds(): string[];
+declare function getAllAgents(): AgentConfig[];
+//#endregion
+//#region src/env/detect.d.ts
+interface DetectedAgent {
+  id: string;
+  config: AgentConfig;
+  detected: "env" | "config" | "both";
+}
+declare function detectAgentByEnv(agent: AgentConfig): boolean;
+declare function detectCurrentAgent(): DetectedAgent | undefined;
+declare function detectInstalledAgents(): DetectedAgent[];
+declare function isRunningInAgent(agentId: string): boolean;
+//#endregion
+//#region src/env/paths.d.ts
+interface XDGPaths {
+  data: string;
+  config: string;
+  cache: string;
+  state: string;
+}
+declare function getXDGPaths(): XDGPaths;
+declare function getAgentConfigDir(agent: AgentConfig): string;
+declare function getAgentRulesPath(agent: AgentConfig): string | undefined;
+declare function getAgentSkillsDir(agent: AgentConfig): string | undefined;
+declare function agentConfigExists(agent: AgentConfig): boolean;
+/** @deprecated Use `hasTTY` from std-env instead */
+declare const isTTY: boolean;
+//#endregion
+export { getAgentConfig as _, getAgentSkillsDir as a, isCI as c, detectAgentByEnv as d, detectCurrentAgent as f, agents as g, AgentConfig as h, getAgentRulesPath as i, isTTY as l, isRunningInAgent as m, agentConfigExists as n, getXDGPaths as o, detectInstalledAgents as p, getAgentConfigDir as r, hasTTY as s, XDGPaths as t, DetectedAgent as u, getAgentIds as v, getAllAgents as y };

package/dist/index-CFwFmDD-.d.ts

@@ -0,0 +1,40 @@
+//#region src/link/copy.d.ts
+interface CopyOptions {
+  force?: boolean;
+  exclude?: string[];
+  preserveTimestamps?: boolean;
+}
+interface CopyResult {
+  success: boolean;
+  src: string;
+  dest: string;
+  filesCopied?: number;
+  error?: string;
+}
+declare function copyDirectory(src: string, dest: string, options?: CopyOptions): CopyResult;
+declare function copyFile(src: string, dest: string, options?: {
+  force?: boolean;
+}): boolean;
+declare function getDirectorySize(dir: string): number;
+//#endregion
+//#region src/link/sanitize.d.ts
+declare function sanitizeName(name: string): string;
+declare function isPathSafe(targetPath: string, baseDir: string): boolean;
+declare function validateSymlinkTarget(target: string): boolean;
+//#endregion
+//#region src/link/symlink.d.ts
+interface SymlinkOptions {
+  force?: boolean;
+  relative?: boolean;
+}
+interface SymlinkResult {
+  success: boolean;
+  path: string;
+  target: string;
+  error?: string;
+}
+declare function createSymlink(target: string, linkPath: string, options?: SymlinkOptions): SymlinkResult;
+declare function isSymlink(path: string): boolean;
+declare function removeSymlink(linkPath: string): boolean;
+//#endregion
+export { removeSymlink as a, validateSymlinkTarget as c, copyDirectory as d, copyFile as f, isSymlink as i, CopyOptions as l, SymlinkResult as n, isPathSafe as o, getDirectorySize as p, createSymlink as r, sanitizeName as s, SymlinkOptions as t, CopyResult as u };

package/dist/index-CirIJDiq.d.ts

@@ -0,0 +1,34 @@
+//#region src/utils/ansi.d.ts
+declare const ANSI: {
+  readonly reset: "\x1B[0m";
+  readonly bold: "\x1B[1m";
+  readonly dim: "\x1B[2m";
+  readonly red: "\x1B[31m";
+  readonly green: "\x1B[32m";
+  readonly yellow: "\x1B[33m";
+  readonly blue: "\x1B[34m";
+  readonly magenta: "\x1B[35m";
+  readonly cyan: "\x1B[36m";
+  readonly white: "\x1B[37m";
+  readonly gray: "\x1B[90m";
+};
+declare function stripAnsi(str: string): string;
+declare function bold(str: string): string;
+declare function dim(str: string): string;
+declare function red(str: string): string;
+declare function green(str: string): string;
+declare function yellow(str: string): string;
+declare function blue(str: string): string;
+declare function cyan(str: string): string;
+declare function gray(str: string): string;
+//#endregion
+//#region src/utils/format.d.ts
+declare function formatList(items: string[], maxShow?: number): string;
+declare function pluralize(count: number, singular: string, plural?: string): string;
+declare function truncate(str: string, maxLength: number, suffix?: string): string;
+//#endregion
+//#region src/utils/path.d.ts
+declare function shortenPath(filepath: string, cwd?: string): string;
+declare function expandPath(filepath: string): string;
+//#endregion
+export { truncate as a, bold as c, gray as d, green as f, yellow as h, pluralize as i, cyan as l, stripAnsi as m, shortenPath as n, ANSI as o, red as p, formatList as r, blue as s, expandPath as t, dim as u };