@agenthippo-ai/agenthippo 0.1.0

package/out/cli/vscode-shim.js

@@ -0,0 +1,86 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = exports.Disposable = exports.Memento = exports.Uri = exports.commands = exports.workspace = exports.window = void 0;
+/**
+ * VS Code Shim for CLI/Headless Mode
+ *
+ * This module provides stub implementations of VS Code APIs
+ * so that code can be bundled for CLI use without the vscode module.
+ */
+// Stub window API
+exports.window = {
+    showInformationMessage: () => undefined,
+    showErrorMessage: () => undefined,
+    showWarningMessage: () => Promise.resolve(undefined),
+    createOutputChannel: () => ({
+        appendLine: () => { },
+        append: () => { },
+        show: () => { },
+        dispose: () => { },
+    }),
+};
+// Stub workspace API
+exports.workspace = {
+    getConfiguration: () => ({
+        get: (_key, defaultValue) => defaultValue,
+        inspect: () => undefined,
+    }),
+    workspaceFolders: undefined,
+    onDidChangeConfiguration: () => ({ dispose: () => { } }),
+};
+// Stub commands API
+exports.commands = {
+    executeCommand: async () => undefined,
+    registerCommand: () => ({ dispose: () => { } }),
+};
+// Stub Uri class
+class Uri {
+    static file(path) {
+        return { fsPath: path, path, scheme: 'file' };
+    }
+    static parse(value) {
+        return { fsPath: value, path: value, scheme: 'file' };
+    }
+}
+exports.Uri = Uri;
+// Stub Memento class
+class Memento {
+    _data = {};
+    get(key) {
+        return this._data[key];
+    }
+    update(key, value) {
+        this._data[key] = value;
+        return Promise.resolve();
+    }
+}
+exports.Memento = Memento;
+// Stub Disposable
+class Disposable {
+    constructor(_callOnDispose) { }
+    dispose() { }
+    static from(..._disposables) {
+        return new Disposable(() => { });
+    }
+}
+exports.Disposable = Disposable;
+// Stub EventEmitter
+class EventEmitter {
+    event = () => ({ dispose: () => { } });
+    fire(_data) { }
+    dispose() { }
+}
+exports.EventEmitter = EventEmitter;
+// Export everything as default for module resolution
+exports.default = {
+    window: exports.window,
+    workspace: exports.workspace,
+    commands: exports.commands,
+    Uri,
+    Memento,
+    Disposable,
+    EventEmitter,
+};

package/out/engines/base.js

@@ -0,0 +1,159 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLiteLLMMetadataHeaders = buildLiteLLMMetadataHeaders;
+exports.resolveAnalyticsProjectId = resolveAnalyticsProjectId;
+exports.generateRequestId = generateRequestId;
+exports.persistSessionIfNeeded = persistSessionIfNeeded;
+exports.touchSessionIfNeeded = touchSessionIfNeeded;
+exports.getPersistedSessionId = getPersistedSessionId;
+const session_1 = require("../session");
+const path = __importStar(require("path"));
+/**
+ * Builds LiteLLM metadata headers for OTEL analytics and optional Langfuse.
+ * Used by both Claude and Codex engines to inject analytics headers.
+ *
+ * Primary path: x-litellm-metadata-* headers → LiteLLM metadata.requester_metadata
+ * OTEL span attribute → traces.jsonl → DuckDB regex extraction.
+ *
+ * Langfuse passthrough: langfuse_session_id / langfuse_trace_user_id headers
+ * are included so users who add Langfuse as a LiteLLM callback get session
+ * grouping automatically.
+ */
+function buildLiteLLMMetadataHeaders(useLiteLLM, metadata) {
+    if (!useLiteLLM) {
+        return [];
+    }
+    const headers = [];
+    if (metadata.analyticsUserId?.trim()) {
+        headers.push(`x-litellm-metadata-user-id: ${metadata.analyticsUserId.trim()}`);
+        // Langfuse passthrough: maps to Langfuse trace user_id when Langfuse callback is enabled
+        headers.push(`langfuse_trace_user_id: ${metadata.analyticsUserId.trim()}`);
+    }
+    if (metadata.sessionId?.trim()) {
+        headers.push(`x-litellm-metadata-session-id: ${metadata.sessionId.trim()}`);
+        // Langfuse passthrough: maps to Langfuse session_id when Langfuse callback is enabled
+        headers.push(`langfuse_session_id: ${metadata.sessionId.trim()}`);
+    }
+    if (metadata.analyticsProjectId?.trim()) {
+        headers.push(`x-litellm-metadata-project-id: ${metadata.analyticsProjectId.trim()}`);
+    }
+    if (metadata.agentId?.trim()) {
+        headers.push(`x-litellm-metadata-agent-id: ${metadata.agentId.trim()}`);
+    }
+    if (metadata.agentVersion?.trim()) {
+        headers.push(`x-litellm-metadata-agent-version: ${metadata.agentVersion.trim()}`);
+    }
+    if (metadata.source?.trim()) {
+        headers.push(`x-litellm-metadata-source: ${metadata.source.trim()}`);
+    }
+    if (metadata.engine?.trim()) {
+        headers.push(`x-litellm-metadata-engine: ${metadata.engine.trim()}`);
+    }
+    if (metadata.requestId?.trim()) {
+        headers.push(`x-litellm-metadata-request-id: ${metadata.requestId.trim()}`);
+    }
+    return headers;
+}
+/**
+ * Resolve analytics project ID. Uses an explicit override when provided,
+ * otherwise falls back to the workspace folder name.
+ */
+function resolveAnalyticsProjectId(explicitProjectId, workspaceRoot) {
+    const explicit = explicitProjectId?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    if (!workspaceRoot) {
+        return undefined;
+    }
+    const normalizedRoot = workspaceRoot.replace(/[\\/]+$/, '').trim();
+    if (!normalizedRoot) {
+        return undefined;
+    }
+    const projectId = path.basename(normalizedRoot).trim();
+    return projectId || undefined;
+}
+/**
+ * Generate a short request ID for grouping LLM calls within one user request.
+ * Format: req-<8 hex chars> - distinguishable from session IDs at a glance.
+ */
+function generateRequestId() {
+    const hex = Math.random().toString(16).slice(2, 10);
+    return `req-${hex}`;
+}
+// -----------------------------------------------------------------------------
+// Session Persistence Helpers
+// -----------------------------------------------------------------------------
+/**
+ * Persist session if not ephemeral.
+ * Common pattern used by both Codex and Claude engines.
+ */
+async function persistSessionIfNeeded(engineId, convo, sessionOrThreadId, options) {
+    if (convo.isEphemeral) {
+        return;
+    }
+    const now = Date.now();
+    const existing = (0, session_1.getPersistedSession)(convo.key);
+    await (0, session_1.upsertPersistedSession)(convo.key, {
+        provider: engineId,
+        id: sessionOrThreadId,
+        chatSessionId: convo.chatSessionId,
+        signatureHash: convo.signatureHash,
+        signatureRaw: convo.signatureRaw,
+        agentPackId: options?.agentPackId ?? convo.agentPackId,
+        agentPackVersion: options?.agentPackVersion,
+        createdAt: existing?.createdAt ?? now,
+        lastUsedAt: now
+    });
+}
+/**
+ * Touch persisted session after a turn completes.
+ */
+function touchSessionIfNeeded(convo) {
+    if (!convo.isEphemeral) {
+        void (0, session_1.touchPersistedSession)(convo.key);
+    }
+}
+/**
+ * Get persisted session ID for resume (if any).
+ */
+function getPersistedSessionId(engineId, conversationKey) {
+    const persisted = (0, session_1.getPersistedSession)(conversationKey);
+    return persisted?.provider === engineId ? persisted.id : undefined;
+}