@agenthippo-ai/agenthippo 0.1.0

package/out/scripts/analytics/install-analytics.sh

@@ -0,0 +1,286 @@
+#!/usr/bin/env bash
+#
+# Copyright (c) AgentHippo.ai. All rights reserved.
+#
+# AgentHippo Analytics Stack Installer
+# Installs OTEL Collector + DuckDB for lightweight observability
+#
+# Usage:
+#   ./install-analytics.sh           # Install both
+#   ./install-analytics.sh --otel    # Install OTEL Collector only
+#   ./install-analytics.sh --duckdb  # Install DuckDB only
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# AGENT_HOME_DIR is set by the extension with the branded directory path
+# Falls back to ~/.agent-hippo for manual script runs
+AGENT_HOME_DIR="${AGENT_HOME_DIR:-$HOME/.agent-hippo}"
+ANALYTICS_DIR="${AGENT_HOME_DIR}/analytics"
+BIN_DIR="${AGENT_HOME_DIR}/bin"
+
+# Versions
+OTEL_VERSION="${OTEL_VERSION:-0.147.0}"
+DUCKDB_VERSION="${DUCKDB_VERSION:-1.1.3}"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+log_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
+log_success() { echo -e "${GREEN}[OK]${NC} $1"; }
+log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
+log_error() { echo -e "${RED}[ERROR]${NC} $1"; }
+
+# Parse arguments
+INSTALL_OTEL=true
+INSTALL_DUCKDB=true
+
+for arg in "$@"; do
+    case $arg in
+        --otel)
+            INSTALL_DUCKDB=false
+            ;;
+        --duckdb)
+            INSTALL_OTEL=false
+            ;;
+        --help|-h)
+            echo "Usage: $0 [--otel] [--duckdb]"
+            echo ""
+            echo "Options:"
+            echo "  --otel    Install OTEL Collector only"
+            echo "  --duckdb  Install DuckDB only"
+            echo ""
+            echo "Without options, installs both."
+            exit 0
+            ;;
+    esac
+done
+
+# Detect OS and architecture
+detect_platform() {
+    local os arch
+
+    case "$(uname -s)" in
+        Darwin) os="darwin" ;;
+        Linux)  os="linux" ;;
+        MINGW*|MSYS*|CYGWIN*) os="windows" ;;
+        *) log_error "Unsupported OS: $(uname -s)"; exit 1 ;;
+    esac
+
+    case "$(uname -m)" in
+        x86_64|amd64) arch="amd64" ;;
+        arm64|aarch64) arch="arm64" ;;
+        *) log_error "Unsupported architecture: $(uname -m)"; exit 1 ;;
+    esac
+
+    echo "${os}_${arch}"
+}
+
+PLATFORM=$(detect_platform)
+log_info "Detected platform: ${PLATFORM}"
+
+# Create directories
+mkdir -p "${BIN_DIR}"
+mkdir -p "${ANALYTICS_DIR}/traces"
+mkdir -p "${ANALYTICS_DIR}/config"
+
+# Install OTEL Collector
+install_otel_collector() {
+    log_info "Installing OTEL Collector v${OTEL_VERSION}..."
+
+    # Check if already installed
+    if command -v otelcol-contrib &> /dev/null; then
+        log_success "OTEL Collector already installed (system)"
+        return 0
+    fi
+
+    if [[ -x "${BIN_DIR}/otelcol-contrib" ]]; then
+        log_success "OTEL Collector already installed (${BIN_DIR})"
+        return 0
+    fi
+
+    # OTEL Collector is not in Homebrew, always download binary
+    # Map platform to OTEL release naming
+    local otel_platform
+    case "${PLATFORM}" in
+        darwin_amd64) otel_platform="darwin_amd64" ;;
+        darwin_arm64) otel_platform="darwin_arm64" ;;
+        linux_amd64)  otel_platform="linux_amd64" ;;
+        linux_arm64)  otel_platform="linux_arm64" ;;
+        windows_amd64) otel_platform="windows_amd64" ;;
+        *) log_error "Unsupported platform for OTEL Collector: ${PLATFORM}"; exit 1 ;;
+    esac
+
+    local url="https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v${OTEL_VERSION}/otelcol-contrib_${OTEL_VERSION}_${otel_platform}.tar.gz"
+    local tmp_dir=$(mktemp -d)
+
+    log_info "Downloading from ${url}..."
+    if ! curl -fsSL "${url}" -o "${tmp_dir}/otelcol.tar.gz"; then
+        log_error "Failed to download OTEL Collector"
+        log_info "Try manually: curl -L '${url}' -o otelcol.tar.gz"
+        rm -rf "${tmp_dir}"
+        exit 1
+    fi
+
+    log_info "Extracting..."
+    tar -xzf "${tmp_dir}/otelcol.tar.gz" -C "${tmp_dir}"
+    mv "${tmp_dir}/otelcol-contrib" "${BIN_DIR}/"
+    chmod +x "${BIN_DIR}/otelcol-contrib"
+
+    rm -rf "${tmp_dir}"
+    log_success "OTEL Collector installed to ${BIN_DIR}/otelcol-contrib"
+}
+
+# Install DuckDB
+install_duckdb() {
+    log_info "Installing DuckDB v${DUCKDB_VERSION}..."
+
+    # Check if already installed
+    if command -v duckdb &> /dev/null; then
+        log_success "DuckDB already installed (system)"
+        return 0
+    fi
+
+    if [[ -x "${BIN_DIR}/duckdb" ]]; then
+        log_success "DuckDB already installed (${BIN_DIR})"
+        return 0
+    fi
+
+    # Try Homebrew on macOS
+    if [[ "${PLATFORM}" == darwin_* ]] && command -v brew &> /dev/null; then
+        log_info "Installing via Homebrew..."
+        brew install duckdb
+        log_success "DuckDB installed via Homebrew"
+        return 0
+    fi
+
+    # Map platform to DuckDB naming
+    local duckdb_platform
+    case "${PLATFORM}" in
+        darwin_amd64) duckdb_platform="osx-universal" ;;
+        darwin_arm64) duckdb_platform="osx-universal" ;;
+        linux_amd64)  duckdb_platform="linux-amd64" ;;
+        linux_arm64)  duckdb_platform="linux-aarch64" ;;
+        windows_amd64) duckdb_platform="windows-amd64" ;;
+        *) log_error "Unsupported platform for DuckDB: ${PLATFORM}"; exit 1 ;;
+    esac
+
+    local url="https://github.com/duckdb/duckdb/releases/download/v${DUCKDB_VERSION}/duckdb_cli-${duckdb_platform}.zip"
+    local tmp_dir=$(mktemp -d)
+
+    log_info "Downloading from ${url}..."
+    curl -fsSL "${url}" -o "${tmp_dir}/duckdb.zip"
+
+    log_info "Extracting..."
+    unzip -q "${tmp_dir}/duckdb.zip" -d "${tmp_dir}"
+    mv "${tmp_dir}/duckdb" "${BIN_DIR}/"
+    chmod +x "${BIN_DIR}/duckdb"
+
+    rm -rf "${tmp_dir}"
+    log_success "DuckDB installed to ${BIN_DIR}/duckdb"
+}
+
+# Copy config files
+setup_config() {
+    log_info "Setting up configuration..."
+
+    # Copy OTEL Collector config
+    if [[ -f "${SCRIPT_DIR}/otel-collector.yaml" ]]; then
+        cp "${SCRIPT_DIR}/otel-collector.yaml" "${ANALYTICS_DIR}/config/"
+        log_success "OTEL Collector config copied"
+    fi
+
+    # Create DuckDB helper script
+    cat > "${ANALYTICS_DIR}/queries.sql" << 'EOF'
+-- AgentHippo Analytics Queries
+-- Usage: duckdb -c ".read ~/.agent-hippo/analytics/queries.sql"
+
+-- Create view for traces
+CREATE OR REPLACE VIEW traces AS
+SELECT
+    json_extract_string(line, '$.resourceSpans[0].scopeSpans[0].spans[0].traceId') as trace_id,
+    json_extract_string(line, '$.resourceSpans[0].scopeSpans[0].spans[0].name') as span_name,
+    json_extract_string(line, '$.resourceSpans[0].scopeSpans[0].spans[0].attributes') as attributes_json,
+    json_extract_string(line, '$.resourceSpans[0].scopeSpans[0].spans[0].startTimeUnixNano') as start_time,
+    json_extract_string(line, '$.resourceSpans[0].scopeSpans[0].spans[0].endTimeUnixNano') as end_time
+FROM read_json('~/.agent-hippo/analytics/traces/*.jsonl',
+               format='newline_delimited',
+               columns={line: 'JSON'});
+
+-- Cost per session
+CREATE OR REPLACE VIEW cost_by_session AS
+SELECT
+    json_extract_string(attributes_json, '$.session_id') as session_id,
+    SUM(CAST(json_extract(attributes_json, '$.llm.cost') AS DOUBLE)) as total_cost,
+    COUNT(*) as request_count
+FROM traces
+GROUP BY session_id
+ORDER BY total_cost DESC;
+
+-- Cost by model
+CREATE OR REPLACE VIEW cost_by_model AS
+SELECT
+    json_extract_string(attributes_json, '$.llm.model') as model,
+    SUM(CAST(json_extract(attributes_json, '$.llm.cost') AS DOUBLE)) as total_cost,
+    SUM(CAST(json_extract(attributes_json, '$.llm.input_tokens') AS INTEGER)) as input_tokens,
+    SUM(CAST(json_extract(attributes_json, '$.llm.output_tokens') AS INTEGER)) as output_tokens,
+    COUNT(*) as request_count
+FROM traces
+GROUP BY model
+ORDER BY total_cost DESC;
+
+-- Today's usage
+CREATE OR REPLACE VIEW today_usage AS
+SELECT * FROM cost_by_session
+WHERE session_id IS NOT NULL;
+
+.print 'Views created: traces, cost_by_session, cost_by_model, today_usage'
+.print 'Try: SELECT * FROM cost_by_session LIMIT 10;'
+EOF
+    log_success "DuckDB queries created"
+}
+
+# Add to PATH hint
+show_path_hint() {
+    echo ""
+    log_info "Add to your PATH (optional):"
+    echo "  export PATH=\"\$PATH:${BIN_DIR}\""
+    echo ""
+    log_info "Start analytics collector:"
+    echo "  ${BIN_DIR}/otelcol-contrib --config ${ANALYTICS_DIR}/config/otel-collector.yaml"
+    echo ""
+    log_info "Query analytics:"
+    echo "  ${BIN_DIR}/duckdb -c \"SELECT * FROM read_json('${ANALYTICS_DIR}/traces/*.jsonl') LIMIT 10\""
+    echo ""
+}
+
+# Main
+main() {
+    echo ""
+    # allow-any-unicode-next-line
+    echo "🦛 AgentHippo Analytics Stack Installer"
+    echo "========================================"
+    echo ""
+
+    if [[ "${INSTALL_OTEL}" == true ]]; then
+        install_otel_collector
+    fi
+
+    if [[ "${INSTALL_DUCKDB}" == true ]]; then
+        install_duckdb
+    fi
+
+    setup_config
+
+    echo ""
+    log_success "Installation complete!"
+    show_path_hint
+}
+
+main "$@"
+

package/out/scripts/analytics/live-fleet-4-collector.cjs

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/* Copyright (c) AgentHippo.ai. All rights reserved. */
+/* Live Fleet 4 collector: fleet-workflows + history archives. */
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const BRAND_DIR = '.agent-hippo';
+const WORKFLOWS_DIRNAME = 'fleet-workflows';
+const HISTORY_DIRNAME = 'history';
+const DEFAULT_VIEW_ID = 'live-fleet-4';
+const KNOWN_WORKSPACES_FILE = 'known-workspaces.json';
+
+function resolveViewId() {
+	const fromEnv = (process.env.AGENTIDE_VIEW_ID || '').trim();
+	if (fromEnv) {
+		return fromEnv;
+	}
+	const viewRoot = (process.env.AGENTIDE_VIEW_ROOT || '').trim();
+	if (viewRoot) {
+		const base = path.basename(path.resolve(viewRoot));
+		if (base) {
+			return base;
+		}
+	}
+	return DEFAULT_VIEW_ID;
+}
+
+function resolveSnapshotFile(viewId = resolveViewId()) {
+	return `${viewId}.json`;
+}
+
+function getAgentHome() {
+	const fromEnv = (process.env.AGENTHIPPO_HOME || process.env.AGENT_HOME || '').trim();
+	return fromEnv ? path.resolve(fromEnv) : path.join(os.homedir(), BRAND_DIR);
+}
+
+function parsePathsMdWorkspace(pathsMdPath) {
+	try {
+		const text = fs.readFileSync(pathsMdPath, 'utf8');
+		const match = text.match(/\*\*Workspace:\*\*\s*`([^`]+)`/);
+		return match ? match[1].trim() : '';
+	} catch {
+		return '';
+	}
+}
+
+function resolveWorkspaces(options = {}) {
+	const seen = new Set();
+	const roots = [];
+	const add = (value) => {
+		const trimmed = String(value || '').trim();
+		if (!trimmed) return;
+		const resolved = path.resolve(trimmed);
+		if (seen.has(resolved)) return;
+		seen.add(resolved);
+		roots.push(resolved);
+	};
+
+	for (const entry of (process.env.LIVE_FLEET_WORKSPACES || '').split(',')) {
+		add(entry);
+	}
+	add(options.workspaceRoot);
+	add(process.env.AGENTIDE_WORKSPACE_ROOT);
+	add(parsePathsMdWorkspace(path.join(getAgentHome(), 'paths.md')));
+	add(parsePathsMdWorkspace(path.join(process.cwd(), BRAND_DIR, 'paths.md')));
+	add(process.cwd());
+
+	return roots.filter((root) => {
+		try {
+			return fs.statSync(root).isDirectory();
+		} catch {
+			return false;
+		}
+	});
+}
+
+function persistKnownWorkspaces(exportDir, workspaces) {
+	if (!exportDir) return;
+	const knownPath = path.join(exportDir, KNOWN_WORKSPACES_FILE);
+	let existing = { workspaces: [] };
+	try {
+		existing = JSON.parse(fs.readFileSync(knownPath, 'utf8'));
+	} catch { /* first run */ }
+	const merged = new Set([
+		...(Array.isArray(existing.workspaces) ? existing.workspaces : []),
+		...workspaces,
+	]);
+	const nextWorkspaces = Array.from(merged).sort();
+	const prevWorkspaces = Array.isArray(existing.workspaces) ? [...existing.workspaces].sort() : [];
+	if (nextWorkspaces.length === prevWorkspaces.length
+		&& nextWorkspaces.every((ws, i) => ws === prevWorkspaces[i])) {
+		return;
+	}
+	fs.mkdirSync(exportDir, { recursive: true });
+	fs.writeFileSync(knownPath, `${JSON.stringify({
+		updatedAt: new Date().toISOString(),
+		workspaces: nextWorkspaces,
+	}, null, 2)}\n`, 'utf8');
+}
+
+function readWorkflowFile(filePath, workspaceRoot, kind) {
+	try {
+		const raw = fs.readFileSync(filePath, 'utf8');
+		const doc = JSON.parse(raw);
+		if (!doc || typeof doc !== 'object') return null;
+		const stat = fs.statSync(filePath);
+		const base = path.basename(filePath, '.json');
+		return {
+			...doc,
+			kind: doc.kind || kind,
+			runId: doc.runId || base.split('-').slice(-1)[0],
+			_file: filePath,
+			_workspaceRoot: workspaceRoot,
+			_mtimeMs: stat.mtimeMs,
+		};
+	} catch {
+		return null;
+	}
+}
+
+function scanDir(dir, workspaceRoot, kind) {
+	const workflows = [];
+	if (!dir) return workflows;
+	try {
+		for (const file of fs.readdirSync(dir)) {
+			if (!file.endsWith('.json') || file.startsWith('.')) continue;
+			const filePath = path.join(dir, file);
+			const doc = readWorkflowFile(filePath, workspaceRoot, kind);
+			if (doc) workflows.push(doc);
+		}
+	} catch { /* missing */ }
+	return workflows;
+}
+
+function scanWorkspace(workspaceRoot) {
+	const root = path.join(workspaceRoot, BRAND_DIR, WORKFLOWS_DIRNAME);
+	const active = scanDir(root, workspaceRoot, 'active');
+	const history = scanDir(path.join(root, HISTORY_DIRNAME), workspaceRoot, 'history');
+	return [...active, ...history];
+}
+
+function detectCliActive() {
+	try {
+		const cmd = process.platform === 'win32' ? 'wmic process get commandline' : 'ps -ax -o command=';
+		const out = execSync(cmd, { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+		return /\bagenthippo\b/i.test(out) && /\b(ask|chat)\b/i.test(out);
+	} catch {
+		return false;
+	}
+}
+
+function normalizeWorkflow(wf) {
+	return {
+		workflowId: wf.workflowId,
+		runId: wf.runId || '',
+		title: wf.title || wf.workflowId,
+		subtitle: wf.subtitle || '',
+		status: wf.status || 'in_progress',
+		kind: wf.kind || 'active',
+		startedAt: wf.startedAt || '',
+		updatedAt: wf.updatedAt || '',
+		finishedAt: wf.finishedAt || '',
+		archivedAt: wf.archivedAt || '',
+		artifact: wf.artifact || wf._file || '',
+		orchestrator: wf.orchestrator || {},
+		steps: (Array.isArray(wf.steps) ? wf.steps : []).slice().sort((a, b) => (a.step || 0) - (b.step || 0)),
+		workspaceRoot: wf._workspaceRoot || '',
+		sourcePath: wf._file || '',
+	};
+}
+
+function workflowKey(wf) {
+	return `${wf.workflowId}::${wf.runId || wf.startedAt || wf.updatedAt}`;
+}
+
+function buildTotals(running, finished, history) {
+	let stepsTotal = 0;
+	let stepsDone = 0;
+	let stepsActive = 0;
+	for (const wf of [...running, ...finished, ...history]) {
+		const steps = wf.steps || [];
+		stepsTotal += steps.length;
+		stepsDone += steps.filter((s) => s.status === 'done').length;
+		stepsActive += steps.filter((s) => s.status === 'in_progress').length;
+	}
+	return {
+		workflows: running.length + finished.length + history.length,
+		running: running.length,
+		finished: history.length,
+		history: history.length,
+		inProgress: running.length,
+		done: history.length + running.filter((w) => w.status === 'done').length,
+		stepsTotal,
+		stepsDone,
+		stepsActive,
+	};
+}
+
+function collect(options = {}) {
+	const exportDir = options.exportDir || '';
+	const workspaces = resolveWorkspaces(options);
+	if (exportDir) persistKnownWorkspaces(exportDir, workspaces);
+
+	const all = [];
+	for (const root of workspaces) {
+		all.push(...scanWorkspace(root));
+	}
+
+	const byKey = new Map();
+	for (const wf of all) {
+		const normalized = normalizeWorkflow(wf);
+		const key = workflowKey(normalized);
+		const existing = byKey.get(key);
+		if (!existing || (wf._mtimeMs || 0) >= (existing._mtimeMs || 0)) {
+			byKey.set(key, { ...normalized, _mtimeMs: wf._mtimeMs });
+		}
+	}
+
+	const workflows = Array.from(byKey.values()).map(({ _mtimeMs, ...rest }) => rest);
+	const running = workflows.filter((w) => w.kind === 'active' && w.status === 'in_progress')
+		.sort((a, b) => Date.parse(b.updatedAt || '') - Date.parse(a.updatedAt || ''));
+	const finished = workflows.filter((w) => w.kind === 'active' && w.status === 'done')
+		.sort((a, b) => Date.parse(b.finishedAt || b.updatedAt || '') - Date.parse(a.finishedAt || a.updatedAt || ''));
+	const history = workflows.filter((w) => w.kind === 'history')
+		.sort((a, b) => Date.parse(b.archivedAt || b.finishedAt || b.updatedAt || '') - Date.parse(a.archivedAt || a.finishedAt || a.updatedAt || ''));
+
+	return {
+		generatedAt: new Date().toISOString(),
+		source: resolveViewId(),
+		totals: buildTotals(running, finished, history),
+		running,
+		finished,
+		history,
+		workflows: [...running, ...finished, ...history],
+		diagnostics: {
+			workspaces,
+			cliActive: detectCliActive(),
+			workflowCount: workflows.length,
+		},
+	};
+}
+
+/** Compare export bodies ignoring generatedAt and volatile CLI hints. */
+function stableExportString(payload) {
+	const clone = { ...payload };
+	delete clone.generatedAt;
+	if (clone.diagnostics && typeof clone.diagnostics === 'object') {
+		const diag = { ...clone.diagnostics };
+		delete diag.cliActive;
+		clone.diagnostics = diag;
+	}
+	return JSON.stringify(clone);
+}
+
+function writeSnapshot(exportDir, payload) {
+	fs.mkdirSync(exportDir, { recursive: true });
+	const exportPath = path.join(exportDir, resolveSnapshotFile());
+	let existingRaw = '';
+	let existingGeneratedAt = '';
+	try {
+		existingRaw = fs.readFileSync(exportPath, 'utf8');
+		const existing = JSON.parse(existingRaw);
+		existingGeneratedAt = existing.generatedAt || '';
+		if (stableExportString(existing) === stableExportString(payload)) {
+			return { exportPath, changed: false };
+		}
+	} catch { /* first write */ }
+
+	const toWrite = {
+		...payload,
+		generatedAt: new Date().toISOString(),
+	};
+	const body = `${JSON.stringify(toWrite, null, 2)}\n`;
+	if (existingRaw === body) {
+		return { exportPath, changed: false };
+	}
+	const tmp = `${exportPath}.${process.pid}.tmp`;
+	fs.writeFileSync(tmp, body, 'utf8');
+	fs.renameSync(tmp, exportPath);
+	return { exportPath, changed: true };
+}
+
+function main() {
+	const exportDir = process.env.LIVE_FLEET_EXPORT_DIR
+		? path.resolve(process.env.LIVE_FLEET_EXPORT_DIR)
+		: path.join(__dirname, '..', 'exports');
+	const payload = collect({ exportDir, workspaceRoot: process.env.AGENTIDE_WORKSPACE_ROOT });
+	const { exportPath, changed } = writeSnapshot(exportDir, payload);
+	console.log(`[workflows-collector] ${payload.totals.running} running, ${payload.totals.finished} finished, ${payload.totals.history} history → ${exportPath}${changed ? '' : ' (unchanged)'}`);
+}
+
+module.exports = {
+	get SNAPSHOT_FILE() {
+		return resolveSnapshotFile();
+	},
+	get SOURCE_ID() {
+		return resolveViewId();
+	},
+	resolveViewId,
+	resolveSnapshotFile,
+	collect,
+	writeSnapshot,
+	resolveWorkspaces,
+	getAgentHome,
+	WORKFLOWS_DIRNAME,
+	HISTORY_DIRNAME,
+	persistKnownWorkspaces,
+};
+
+if (require.main === module) {
+	main();
+}