@agenthippo-ai/agenthippo 0.1.0

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

@@ -0,0 +1,259 @@
+#!/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

@@ -0,0 +1,189 @@
+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

@@ -0,0 +1,69 @@
+---
+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

@@ -0,0 +1,63 @@
+#!/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