@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/base-prompts/skills/agent-engine-installer/scripts/install-engine.mjs

@@ -1,259 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import process from 'node:process';
-
-const DEFAULT_REPO_URL = 'git@github.com:agenthippoai/custom-engines.git';
-
-function usage() {
-	return [
-		'Usage:',
-		'  node install-engine.mjs <engine...> [options]',
-		'',
-		'Options:',
-		'  --repo-url <url>       Source Git repo when --source-root is omitted',
-		'  --ref <ref>            Branch, tag, or SHA to checkout in the cache repo',
-		'  --source-root <path>   Existing folder containing engine directories',
-		'  --cache-root <path>    Git cache folder',
-		'  --install-root <path>  Destination engines folder',
-		'  --no-npm-ci           Skip npm ci',
-		'  --help                Show this help',
-	].join('\n');
-}
-
-function parseArgs(argv) {
-	const options = {
-		engines: [],
-		repoUrl: DEFAULT_REPO_URL,
-		ref: '',
-		sourceRoot: '',
-		cacheRoot: '',
-		installRoot: '',
-		noNpmCi: false,
-	};
-
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		if (arg === '--help' || arg === '-h') {
-			console.log(usage());
-			process.exit(0);
-		}
-		if (arg === '--no-npm-ci') {
-			options.noNpmCi = true;
-			continue;
-		}
-		if (arg.startsWith('--')) {
-			const [name, inlineValue] = arg.split(/=(.*)/s, 2);
-			const key = {
-				'--repo-url': 'repoUrl',
-				'--ref': 'ref',
-				'--source-root': 'sourceRoot',
-				'--cache-root': 'cacheRoot',
-				'--install-root': 'installRoot',
-			}[name];
-			if (!key) {
-				throw new Error(`Unknown option: ${name}`);
-			}
-			const value = inlineValue !== undefined ? inlineValue : argv[++i];
-			if (!value) {
-				throw new Error(`Missing value for ${name}`);
-			}
-			options[key] = value;
-			continue;
-		}
-		options.engines.push(arg);
-	}
-
-	if (options.engines.length === 0) {
-		throw new Error(`At least one engine id is required.\n\n${usage()}`);
-	}
-
-	return options;
-}
-
-function fullPath(value) {
-	return path.resolve(value.replace(/^~(?=$|[\\/])/, os.homedir()));
-}
-
-function commandExists(command) {
-	const result = spawnSync(command, ['--version'], {
-		stdio: 'ignore',
-		shell: process.platform === 'win32',
-	});
-	return result.status === 0;
-}
-
-function run(command, args, options = {}) {
-	console.log(`>> ${command} ${args.join(' ')}`);
-	const result = spawnSync(command, args, {
-		cwd: options.cwd,
-		stdio: 'inherit',
-		shell: process.platform === 'win32',
-		env: process.env,
-	});
-	if (result.error) {
-		throw result.error;
-	}
-	if (result.status !== 0) {
-		throw new Error(`Command failed with exit code ${result.status}: ${command} ${args.join(' ')}`);
-	}
-}
-
-function ensureSourceRoot(options) {
-	if (options.sourceRoot.trim()) {
-		const sourceRoot = fullPath(options.sourceRoot);
-		if (!fs.existsSync(sourceRoot) || !fs.statSync(sourceRoot).isDirectory()) {
-			throw new Error(`Source root does not exist: ${sourceRoot}`);
-		}
-		return sourceRoot;
-	}
-
-	if (!commandExists('git')) {
-		throw new Error('git is required when --source-root is not provided');
-	}
-
-	const cacheRoot = fullPath(
-		options.cacheRoot.trim() ||
-		path.join(os.homedir(), '.agent-hippo', 'cache', 'custom-engines', 'agenthippoai-custom-engines'),
-	);
-	fs.mkdirSync(path.dirname(cacheRoot), { recursive: true });
-
-	const gitDir = path.join(cacheRoot, '.git');
-	if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {
-		run('git', ['-C', cacheRoot, 'fetch', '--all', '--tags', '--prune']);
-		if (options.ref.trim()) {
-			run('git', ['-C', cacheRoot, 'checkout', options.ref.trim()]);
-		} else {
-			run('git', ['-C', cacheRoot, 'pull', '--ff-only']);
-		}
-		return cacheRoot;
-	}
-
-	if (fs.existsSync(cacheRoot)) {
-		throw new Error(`Cache root exists but is not a Git checkout: ${cacheRoot}`);
-	}
-
-	run('git', ['clone', options.repoUrl, cacheRoot]);
-	if (options.ref.trim()) {
-		run('git', ['-C', cacheRoot, 'checkout', options.ref.trim()]);
-	}
-	return cacheRoot;
-}
-
-function assertDestinationWithinRoot(destination, installRoot) {
-	const resolvedRoot = fullPath(installRoot);
-	const resolvedDestination = fullPath(destination);
-	const rootPrefix = resolvedRoot.endsWith(path.sep) ? resolvedRoot : `${resolvedRoot}${path.sep}`;
-	if (!resolvedDestination.startsWith(rootPrefix)) {
-		throw new Error(`Refusing to write outside install root: ${resolvedDestination}`);
-	}
-	if (resolvedDestination === resolvedRoot) {
-		throw new Error('Refusing to replace the install root itself');
-	}
-}
-
-function copyDirectoryContents(source, destination) {
-	fs.mkdirSync(destination, { recursive: true });
-	for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
-		if (entry.name === 'node_modules' || entry.name === '.git') {
-			continue;
-		}
-		const src = path.join(source, entry.name);
-		const dest = path.join(destination, entry.name);
-		if (entry.isDirectory()) {
-			fs.cpSync(src, dest, { recursive: true, force: true });
-		} else if (entry.isFile() || entry.isSymbolicLink()) {
-			fs.copyFileSync(src, dest);
-		}
-	}
-}
-
-function readManifest(manifestPath) {
-	let manifest;
-	try {
-		manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-	} catch (err) {
-		throw new Error(`Failed to parse ${manifestPath}: ${err.message}`);
-	}
-	if (manifest.version !== 2) {
-		throw new Error(`Manifest version must be 2: ${manifestPath}`);
-	}
-	if (typeof manifest.id !== 'string' || !manifest.id.trim()) {
-		throw new Error(`Manifest is missing id: ${manifestPath}`);
-	}
-	if (typeof manifest.entry !== 'string' || !manifest.entry.trim()) {
-		throw new Error(`Manifest is missing entry: ${manifestPath}`);
-	}
-	return manifest;
-}
-
-function installEngine(engineName, sourceRoot, installRoot, options) {
-	const source = path.join(sourceRoot, engineName);
-	if (!fs.existsSync(source) || !fs.statSync(source).isDirectory()) {
-		throw new Error(`Engine "${engineName}" not found under source root: ${sourceRoot}`);
-	}
-
-	const sourceManifestPath = path.join(source, 'engine.manifest.json');
-	if (!fs.existsSync(sourceManifestPath)) {
-		throw new Error(`Missing engine.manifest.json for "${engineName}": ${sourceManifestPath}`);
-	}
-
-	const sourceManifest = readManifest(sourceManifestPath);
-	const engineId = sourceManifest.id.trim().toLowerCase();
-	const destination = path.join(installRoot, engineId);
-	assertDestinationWithinRoot(destination, installRoot);
-
-	console.log(`Installing engine "${engineName}" as "${engineId}"`);
-	fs.mkdirSync(installRoot, { recursive: true });
-	if (fs.existsSync(destination)) {
-		fs.rmSync(destination, { recursive: true, force: true });
-	}
-	fs.mkdirSync(destination, { recursive: true });
-	copyDirectoryContents(source, destination);
-
-	const manifest = readManifest(path.join(destination, 'engine.manifest.json'));
-	const entryPath = path.isAbsolute(manifest.entry)
-		? manifest.entry
-		: path.resolve(destination, manifest.entry);
-	if (!fs.existsSync(entryPath)) {
-		throw new Error(`Manifest entry not found after install: ${entryPath}`);
-	}
-
-	const packageJson = path.join(destination, 'package.json');
-	if (fs.existsSync(packageJson) && !options.noNpmCi) {
-		if (!commandExists('npm')) {
-			throw new Error(`npm is required to install dependencies for "${engineId}"`);
-		}
-		const packageLock = path.join(destination, 'package-lock.json');
-		if (!fs.existsSync(packageLock)) {
-			throw new Error(`package-lock.json is required for deterministic npm ci: ${packageLock}`);
-		}
-		run('npm', ['ci', '--prefix', destination, '--omit=dev']);
-	}
-
-	if (!commandExists('node')) {
-		throw new Error('node is required for syntax validation');
-	}
-	run('node', ['--check', entryPath]);
-	console.log(`Installed custom engine "${engineId}" at ${destination}`);
-}
-
-try {
-	const options = parseArgs(process.argv.slice(2));
-	const sourceRoot = ensureSourceRoot(options);
-	const installRoot = fullPath(
-		options.installRoot.trim() ||
-		path.join(os.homedir(), '.agent-hippo', 'engines'),
-	);
-
-	for (const engine of options.engines) {
-		installEngine(engine, sourceRoot, installRoot, options);
-	}
-
-	console.log(`Done. AgentHippo will discover installed engines from: ${installRoot}`);
-} catch (err) {
-	console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
-	process.exit(1);
-}

package/out/base-prompts/skills/agent-engine-installer/scripts/install-engine.ps1

@@ -1,189 +0,0 @@
-param(
-	[Parameter(Mandatory = $true, Position = 0)]
-	[string[]]$Engine,
-
-	[string]$RepoUrl = "git@github.com:agenthippoai/custom-engines.git",
-	[string]$Ref = "",
-	[string]$SourceRoot = "",
-	[string]$CacheRoot = "",
-	[string]$InstallRoot = "",
-	[switch]$NoNpmCi
-)
-
-$ErrorActionPreference = "Stop"
-
-function Get-FullPath {
-	param([Parameter(Mandatory = $true)][string]$Path)
-	return [System.IO.Path]::GetFullPath($ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($Path))
-}
-
-function Test-Command {
-	param([Parameter(Mandatory = $true)][string]$Name)
-	return $null -ne (Get-Command $Name -ErrorAction SilentlyContinue)
-}
-
-function Invoke-Logged {
-	param(
-		[Parameter(Mandatory = $true)][string]$FilePath,
-		[Parameter(Mandatory = $true)][string[]]$Arguments,
-		[string]$WorkingDirectory = ""
-	)
-	$display = "$FilePath $($Arguments -join ' ')"
-	Write-Host ">> $display"
-	if ($WorkingDirectory) {
-		& $FilePath @Arguments
-	} else {
-		& $FilePath @Arguments
-	}
-	if ($LASTEXITCODE -ne 0) {
-		throw "Command failed with exit code ${LASTEXITCODE}: $display"
-	}
-}
-
-function Ensure-SourceRoot {
-	param(
-		[Parameter(Mandatory = $true)][string]$RepoUrl,
-		[string]$Ref,
-		[string]$SourceRoot,
-		[string]$CacheRoot
-	)
-
-	if ($SourceRoot.Trim()) {
-		$resolved = Get-FullPath $SourceRoot
-		if (-not (Test-Path -LiteralPath $resolved -PathType Container)) {
-			throw "SourceRoot does not exist: $resolved"
-		}
-		return $resolved
-	}
-
-	if (-not (Test-Command git)) {
-		throw "git is required when -SourceRoot is not provided"
-	}
-
-	if (-not $CacheRoot.Trim()) {
-		$CacheRoot = Join-Path $HOME ".agent-hippo/cache/custom-engines/agenthippoai-custom-engines"
-	}
-	$cache = Get-FullPath $CacheRoot
-	$cacheParent = Split-Path -Parent $cache
-	New-Item -ItemType Directory -Path $cacheParent -Force | Out-Null
-
-	if (Test-Path -LiteralPath (Join-Path $cache ".git") -PathType Container) {
-		Invoke-Logged git @("-C", $cache, "fetch", "--all", "--tags", "--prune")
-		if ($Ref.Trim()) {
-			Invoke-Logged git @("-C", $cache, "checkout", $Ref)
-		} else {
-			Invoke-Logged git @("-C", $cache, "pull", "--ff-only")
-		}
-	} elseif (Test-Path -LiteralPath $cache) {
-		throw "CacheRoot exists but is not a Git checkout: $cache"
-	} else {
-		Invoke-Logged git @("clone", $RepoUrl, $cache)
-		if ($Ref.Trim()) {
-			Invoke-Logged git @("-C", $cache, "checkout", $Ref)
-		}
-	}
-
-	return $cache
-}
-
-function Copy-EngineFolder {
-	param(
-		[Parameter(Mandatory = $true)][string]$Source,
-		[Parameter(Mandatory = $true)][string]$Destination,
-		[Parameter(Mandatory = $true)][string]$InstallRoot
-	)
-
-	$installRootFull = Get-FullPath $InstallRoot
-	New-Item -ItemType Directory -Path $installRootFull -Force | Out-Null
-	$destFull = [System.IO.Path]::GetFullPath($Destination)
-	$installRootPrefix = $installRootFull.TrimEnd([System.IO.Path]::DirectorySeparatorChar, [System.IO.Path]::AltDirectorySeparatorChar) + [System.IO.Path]::DirectorySeparatorChar
-	if (-not $destFull.StartsWith($installRootPrefix, [System.StringComparison]::OrdinalIgnoreCase)) {
-		throw "Refusing to write outside InstallRoot. Destination: $destFull InstallRoot: $installRootFull"
-	}
-
-	if (Test-Path -LiteralPath $destFull) {
-		Remove-Item -LiteralPath $destFull -Recurse -Force
-	}
-	New-Item -ItemType Directory -Path $destFull -Force | Out-Null
-
-	Get-ChildItem -LiteralPath $Source -Force | ForEach-Object {
-		if ($_.Name -eq "node_modules" -or $_.Name -eq ".git") {
-			return
-		}
-		Copy-Item -LiteralPath $_.FullName -Destination $destFull -Recurse -Force
-	}
-}
-
-function Install-OneEngine {
-	param(
-		[Parameter(Mandatory = $true)][string]$EngineName,
-		[Parameter(Mandatory = $true)][string]$SourceRoot,
-		[Parameter(Mandatory = $true)][string]$InstallRoot,
-		[switch]$NoNpmCi
-	)
-
-	$source = Join-Path $SourceRoot $EngineName
-	if (-not (Test-Path -LiteralPath $source -PathType Container)) {
-		throw "Engine '$EngineName' not found under source root: $SourceRoot"
-	}
-
-	$sourceManifestPath = Join-Path $source "engine.manifest.json"
-	if (-not (Test-Path -LiteralPath $sourceManifestPath -PathType Leaf)) {
-		throw "Missing engine.manifest.json for '$EngineName': $sourceManifestPath"
-	}
-	$manifest = Get-Content -LiteralPath $sourceManifestPath -Raw | ConvertFrom-Json
-	if ($manifest.version -ne 2) {
-		throw "Engine '$EngineName' manifest version must be 2"
-	}
-	if (-not "$($manifest.id)".Trim()) {
-		throw "Engine '$EngineName' manifest is missing id"
-	}
-	if (-not "$($manifest.entry)".Trim()) {
-		throw "Engine '$EngineName' manifest is missing entry"
-	}
-
-	$engineId = "$($manifest.id)".Trim().ToLowerInvariant()
-	$dest = Join-Path $InstallRoot $engineId
-	Write-Host "Installing engine '$EngineName' as '$engineId'"
-	Copy-EngineFolder -Source $source -Destination $dest -InstallRoot $InstallRoot
-
-	$destManifestPath = Join-Path $dest "engine.manifest.json"
-	$destManifest = Get-Content -LiteralPath $destManifestPath -Raw | ConvertFrom-Json
-	$entry = "$($destManifest.entry)".Trim()
-	$entryPath = if ([System.IO.Path]::IsPathRooted($entry)) { $entry } else { Join-Path $dest $entry }
-	if (-not (Test-Path -LiteralPath $entryPath -PathType Leaf)) {
-		throw "Manifest entry not found after install: $entryPath"
-	}
-
-	$packageJson = Join-Path $dest "package.json"
-	if ((Test-Path -LiteralPath $packageJson -PathType Leaf) -and -not $NoNpmCi) {
-		if (-not (Test-Command npm)) {
-			throw "npm is required to install dependencies for '$engineId'"
-		}
-		$packageLock = Join-Path $dest "package-lock.json"
-		if (-not (Test-Path -LiteralPath $packageLock -PathType Leaf)) {
-			throw "package-lock.json is required for deterministic npm ci: $packageLock"
-		}
-		Invoke-Logged npm @("ci", "--prefix", $dest, "--omit=dev")
-	}
-
-	if (-not (Test-Command node)) {
-		throw "node is required for syntax validation"
-	}
-	Invoke-Logged node @("--check", $entryPath)
-
-	Write-Host "Installed custom engine '$engineId' at $dest"
-}
-
-if (-not $InstallRoot.Trim()) {
-	$InstallRoot = Join-Path $HOME ".agent-hippo/engines"
-}
-
-$sourceRootResolved = Ensure-SourceRoot -RepoUrl $RepoUrl -Ref $Ref -SourceRoot $SourceRoot -CacheRoot $CacheRoot
-$installRootResolved = Get-FullPath $InstallRoot
-
-foreach ($engineName in $Engine) {
-	Install-OneEngine -EngineName $engineName -SourceRoot $sourceRootResolved -InstallRoot $installRootResolved -NoNpmCi:$NoNpmCi
-}
-
-Write-Host "Done. AgentHippo will discover installed engines from: $installRootResolved"

package/out/base-prompts/skills/agenthippo-cli/SKILL.md

@@ -1,69 +0,0 @@
----
-name: agenthippo-cli
-description: Ensure the AgentHippo CLI is installed and reachable, installing it automatically if missing. Use as a preflight before any skill or agent that invokes the agenthippo binary (debug-agent, agentpack-testbench, skill-installer, etc.), or when the user reports "agenthippo: command not found".
----
-
-# AgentHippo CLI
-
-Ensure the `agenthippo` CLI is available before running agent commands.
-
-## Preflight (run this first)
-
-```bash
-"${AGENTHIPPO_CLI_PATH:-agenthippo}" --version
-```
-
-If this succeeds, the CLI is ready — no further action needed.
-
-## Quick local LiteLLM smoke test
-
-Use this one-liner to verify the CLI can reach a local LiteLLM proxy and return a deterministic response:
-
-```bash
-AGENTHIPPO_LITELLM_BASE_URL="http://localhost:4000" AGENTHIPPO_LITELLM_API_KEY="dummy" AGENTHIPPO_DEFAULT_MODEL="litellm/gpt-5.3-codex" AGENTHIPPO_DEFAULT_ENGINE="codex" "${AGENTHIPPO_CLI_PATH:-agenthippo}" ask "Reply with exactly: CLI_TEST_OK"
-```
-
-Expected output:
-
-```text
-CLI_TEST_OK
-```
-
-## When to use
-
-- Any skill's preflight fails (`agenthippo --version` returns non-zero or command not found)
-- User reports `agenthippo: command not found`
-- Inside the AgentHippo IDE: use **Agent Hippo: Setup AgentHippo CLI** from the command palette — it handles PATH and IDE restart automatically.
-
-## Install / repair
-
-```bash
-bash <skill_location>/scripts/install.sh
-```
-
-Resolution order:
-1. `$AGENTHIPPO_CLI_PATH` — injected by the AgentHippo IDE
-2. `which agenthippo` — standard PATH
-3. Known install locations (`~/.local/bin`, Homebrew, pnpm, npm global)
-4. Downloads and runs `https://agenthippo.ai/install.sh` if still not found
-
-## After install
-
-If the script exits with "not yet on PATH", reload your shell:
-
-```bash
-source ~/.zshrc   # zsh
-source ~/.bashrc  # bash
-```
-
-Then re-run the preflight.
-
-## Windows
-
-The install script requires WSL or Git Bash. For native PowerShell:
-
-```powershell
-(Invoke-WebRequest https://agenthippo.ai/install.ps1).Content | Invoke-Expression
-```
-
-Or: download `agenthippo.zip` from `https://agenthippo.ai/download`, extract, and run `.\install.ps1`.

package/out/base-prompts/skills/agenthippo-cli/scripts/install.sh

@@ -1,63 +0,0 @@
-#!/usr/bin/env bash
-# Locate or install the agenthippo CLI.
-# Exits 0 and prints the resolved path on success.
-# Exits 1 with an actionable message on failure.
-set -euo pipefail
-
-BINARY="agenthippo"
-
-resolve() {
-  # 1. IDE-injected path (most reliable inside Agent Hippo IDE)
-  if [[ -n "${AGENTHIPPO_CLI_PATH:-}" && -x "${AGENTHIPPO_CLI_PATH}" ]]; then
-    echo "${AGENTHIPPO_CLI_PATH}"; return 0
-  fi
-
-  # 2. PATH
-  if command -v "${BINARY}" >/dev/null 2>&1; then
-    command -v "${BINARY}"; return 0
-  fi
-
-  # 3. Known install locations (mirrors IDE binary.ts getCommonBinaryPaths)
-  local candidates=(
-    "$HOME/.local/bin/${BINARY}"
-    "$HOME/Library/pnpm/${BINARY}"
-    "$HOME/.local/share/pnpm/${BINARY}"
-    "$HOME/.npm-global/bin/${BINARY}"
-    "/opt/homebrew/bin/${BINARY}"
-    "/usr/local/bin/${BINARY}"
-    "/usr/bin/${BINARY}"
-  )
-  for c in "${candidates[@]}"; do
-    [[ -x "$c" ]] && { echo "$c"; return 0; }
-  done
-
-  return 1
-}
-
-if RESOLVED="$(resolve)"; then
-  echo "agenthippo: ${RESOLVED}"
-  "${RESOLVED}" --version 2>/dev/null || true
-  exit 0
-fi
-
-echo "agenthippo not found — installing..."
-
-if command -v curl >/dev/null 2>&1; then
-  curl -fsSL https://agenthippo.ai/install.sh | bash
-elif command -v wget >/dev/null 2>&1; then
-  wget -qO- https://agenthippo.ai/install.sh | bash
-else
-  echo "ERROR: curl and wget unavailable." >&2
-  echo "Download manually: https://agenthippo.ai/download" >&2
-  exit 1
-fi
-
-# Re-resolve after install (PATH may not be updated in this shell)
-if RESOLVED="$(resolve)"; then
-  echo "agenthippo installed: ${RESOLVED}"
-  "${RESOLVED}" --version 2>/dev/null || true
-else
-  echo "Installed, but agenthippo is not yet on PATH." >&2
-  echo "Open a new terminal or run: source ~/.zshrc  (or ~/.bashrc)" >&2
-  exit 1
-fi