@agenthippo-ai/agenthippo 0.1.0

package/out/analytics/dashboard/artifactManager.js

@@ -0,0 +1,439 @@
+"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.ArtifactManagerImpl = void 0;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const index_1 = require("../../utils/index");
+// -----------------------------------------------------------------------------
+// Implementation
+// -----------------------------------------------------------------------------
+const DEFAULT_RETENTION_DAYS = 30;
+const DEBOUNCE_MS = 300;
+class ArtifactManagerImpl {
+    outputChannel;
+    watcher;
+    debounceTimeout;
+    workspaceRootPath;
+    viewContext = { scope: 'global' };
+    constructor(outputChannel) {
+        this.outputChannel = outputChannel;
+    }
+    // -------------------------------------------------------------------------
+    // Directory Management
+    // -------------------------------------------------------------------------
+    setWorkspaceRoot(workspaceRoot) {
+        const normalized = workspaceRoot?.trim();
+        this.workspaceRootPath = normalized || undefined;
+    }
+    setViewContext(context) {
+        this.viewContext = {
+            scope: context.scope === 'workspace' ? 'workspace' : 'global',
+            projectId: context.projectId?.trim() || undefined,
+            agentId: context.agentId?.trim() || undefined,
+            viewId: context.viewId?.trim() || undefined,
+        };
+    }
+    getAnalyticsRoot() {
+        if (this.workspaceRootPath) {
+            return path.join(this.workspaceRootPath, '.agent-hippo', 'analytics');
+        }
+        return path.join((0, index_1.getAgentideHome)(), 'analytics');
+    }
+    /** Home analytics root (global-scope views and store installs). */
+    getGlobalAnalyticsRoot() {
+        return path.join((0, index_1.getAgentideHome)(), 'analytics');
+    }
+    resolveAnalyticsRootForScope(scope) {
+        if (scope === 'workspace' && this.workspaceRootPath) {
+            return path.join(this.workspaceRootPath, '.agent-hippo', 'analytics');
+        }
+        return this.getGlobalAnalyticsRoot();
+    }
+    sanitizePathSegment(value) {
+        const trimmed = value.trim();
+        const sanitized = trimmed.replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+|_+$/g, '');
+        return sanitized || 'default';
+    }
+    /**
+     * Resolve the filesystem root for a view. Views are independent (Global, Workspace, Fleet, or user-created);
+     * each has its own folder under views/<viewId>/.
+     */
+    resolveViewRoot(context) {
+        const root = this.resolveAnalyticsRootForScope(context.scope);
+        const viewSegment = context.viewId
+            ? this.sanitizePathSegment(context.viewId)
+            : 'default';
+        return path.join(root, 'views', viewSegment);
+    }
+    getViewRoot() {
+        return this.resolveViewRoot(this.viewContext);
+    }
+    async ensureWorkspaceRoot() {
+        await fs_1.promises.mkdir(this.getAnalyticsRoot(), { recursive: true });
+    }
+    async ensureArtifactDir() {
+        const analyticsRoot = this.getAnalyticsRoot();
+        const viewRoot = this.getViewRoot();
+        // Per-workspace shared dirs + per-filter per-view dirs.
+        for (const dir of [
+            path.join(analyticsRoot, 'panel'),
+            path.join(analyticsRoot, 'views'),
+            path.join(viewRoot, 'scripts'),
+            path.join(viewRoot, 'charts'),
+            path.join(viewRoot, 'reports'),
+            path.join(viewRoot, 'exports'),
+            path.join(viewRoot, 'images'),
+            path.join(viewRoot, 'assets'),
+        ]) {
+            await fs_1.promises.mkdir(dir, { recursive: true });
+        }
+        return vscode.Uri.file(viewRoot);
+    }
+    async getSubdir(type) {
+        const base = await this.ensureArtifactDir();
+        return vscode.Uri.joinPath(base, type);
+    }
+    getChartDir() {
+        return path.join(this.getViewRoot(), 'charts');
+    }
+    getReportDir() {
+        return path.join(this.getViewRoot(), 'reports');
+    }
+    getExportDir() {
+        return path.join(this.getViewRoot(), 'exports');
+    }
+    getImageDir() {
+        return path.join(this.getViewRoot(), 'images');
+    }
+    getAssetDir() {
+        return path.join(this.getViewRoot(), 'assets');
+    }
+    getScriptDir() {
+        return path.join(this.getViewRoot(), 'scripts');
+    }
+    getPanelDir() {
+        return path.join(this.getAnalyticsRoot(), 'panel');
+    }
+    // -------------------------------------------------------------------------
+    // Artifact Listing
+    // -------------------------------------------------------------------------
+    async listArtifacts() {
+        const artifacts = [];
+        try {
+            const baseDir = await this.ensureArtifactDir();
+            const subdirs = [
+                { name: 'charts', type: 'chart' },
+                { name: 'reports', type: 'report' },
+                { name: 'exports', type: 'export' },
+                { name: 'images', type: 'image' },
+            ];
+            for (const { name, type } of subdirs) {
+                const dir = vscode.Uri.joinPath(baseDir, name);
+                try {
+                    const entries = await vscode.workspace.fs.readDirectory(dir);
+                    for (const [filename, fileType] of entries) {
+                        if (fileType !== vscode.FileType.File) {
+                            continue;
+                        }
+                        if (filename.startsWith('.')) {
+                            continue;
+                        }
+                        const uri = vscode.Uri.joinPath(dir, filename);
+                        const stat = await vscode.workspace.fs.stat(uri);
+                        const format = this.getFormat(filename);
+                        if (!format) {
+                            continue; // Skip unsupported formats
+                        }
+                        artifacts.push({
+                            uri,
+                            filename,
+                            size: stat.size,
+                            createdAt: new Date(stat.ctime),
+                            modifiedAt: new Date(stat.mtime),
+                            type,
+                            format,
+                            generator: await this.extractGenerator(uri, format),
+                        });
+                    }
+                }
+                catch {
+                    // Directory doesn't exist yet, skip
+                }
+            }
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[ArtifactManager] Error listing artifacts: ${err}`);
+        }
+        return artifacts.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+    }
+    getFormat(filename) {
+        const ext = filename.split('.').pop()?.toLowerCase();
+        switch (ext) {
+            case 'png': return 'png';
+            case 'svg': return 'svg';
+            case 'gif': return 'gif';
+            case 'webp': return 'webp';
+            case 'jpg':
+            case 'jpeg': return 'jpg';
+            case 'html': return 'html';
+            case 'md': return 'md';
+            case 'csv': return 'csv';
+            case 'json': return 'json';
+            default: return null;
+        }
+    }
+    async extractGenerator(uri, format) {
+        // Try to extract generator info from file metadata/comments
+        if (format === 'html' || format === 'md') {
+            try {
+                const content = await vscode.workspace.fs.readFile(uri);
+                const text = Buffer.from(content).toString('utf-8').slice(0, 500);
+                const match = text.match(/Generated by:\s*([^\n\-\>]+)/i);
+                return match?.[1]?.trim();
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    // -------------------------------------------------------------------------
+    // Script Discovery
+    // -------------------------------------------------------------------------
+    getScriptLanguage(filename) {
+        const ext = filename.split('.').pop()?.toLowerCase();
+        switch (ext) {
+            case 'py': return 'python';
+            case 'js':
+            case 'mjs':
+            case 'cjs': return 'javascript';
+            case 'sh': return 'shell';
+            default: return null;
+        }
+    }
+    async listScripts(options) {
+        const scripts = [];
+        const disabledScriptSet = new Set((options?.disabledScripts ?? [])
+            .map(value => path.basename(value.trim()).toLowerCase())
+            .filter(Boolean));
+        const skippedScripts = [];
+        try {
+            // Scripts are view-owned under <analyticsRoot>/views/<viewId>/scripts.
+            const scriptsDir = vscode.Uri.file(this.getScriptDir());
+            try {
+                const entries = await vscode.workspace.fs.readDirectory(scriptsDir);
+                for (const [filename, fileType] of entries) {
+                    if (fileType !== vscode.FileType.File) {
+                        continue;
+                    }
+                    if (filename.startsWith('.')) {
+                        continue;
+                    }
+                    const language = this.getScriptLanguage(filename);
+                    if (!language) {
+                        continue;
+                    }
+                    if (disabledScriptSet.has(path.basename(filename).toLowerCase())) {
+                        skippedScripts.push(filename);
+                        continue;
+                    }
+                    scripts.push({
+                        uri: vscode.Uri.joinPath(scriptsDir, filename),
+                        filename,
+                        language,
+                    });
+                }
+            }
+            catch {
+                // scripts/ doesn't exist yet
+            }
+        }
+        catch (err) {
+            this.outputChannel.appendLine(`[ArtifactManager] Error listing scripts: ${err}`);
+        }
+        if (skippedScripts.length > 0) {
+            this.outputChannel.appendLine(`[ArtifactManager] Skipping disabled scripts: ${skippedScripts.join(', ')}`);
+        }
+        return scripts;
+    }
+    async ensureSeedScripts(scripts) {
+        if (scripts.length === 0) {
+            return;
+        }
+        await this.ensureWorkspaceRoot();
+        const scriptsDir = this.getScriptDir();
+        await fs_1.promises.mkdir(scriptsDir, { recursive: true });
+        for (const script of scripts) {
+            const sourcePath = script.sourcePath.trim();
+            if (!sourcePath) {
+                continue;
+            }
+            try {
+                const sourceStat = await fs_1.promises.stat(sourcePath);
+                if (!sourceStat.isFile()) {
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            const filename = script.filename?.trim() || path.basename(sourcePath);
+            const destinationPath = path.join(scriptsDir, filename);
+            try {
+                await fs_1.promises.access(destinationPath);
+                continue; // Respect user modifications once file exists.
+            }
+            catch {
+                // Missing destination, seed it.
+            }
+            try {
+                await fs_1.promises.copyFile(sourcePath, destinationPath);
+            }
+            catch (err) {
+                this.outputChannel.appendLine(`[ArtifactManager] Failed seeding script ${filename}: ${err}`);
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // File Watching
+    // -------------------------------------------------------------------------
+    watchForChanges(callback) {
+        const analyticsRoot = this.getAnalyticsRoot();
+        const pattern = new vscode.RelativePattern(analyticsRoot, `**/*.{png,svg,jpg,jpeg,gif,webp,html,md,csv,json}`);
+        this.watcher = vscode.workspace.createFileSystemWatcher(pattern);
+        const debouncedRefresh = () => {
+            if (this.debounceTimeout) {
+                clearTimeout(this.debounceTimeout);
+            }
+            this.debounceTimeout = setTimeout(async () => {
+                const artifacts = await this.listArtifacts();
+                callback(artifacts);
+            }, DEBOUNCE_MS);
+        };
+        this.watcher.onDidCreate(debouncedRefresh);
+        this.watcher.onDidChange(debouncedRefresh);
+        this.watcher.onDidDelete(debouncedRefresh);
+        return {
+            dispose: () => {
+                this.watcher?.dispose();
+                if (this.debounceTimeout) {
+                    clearTimeout(this.debounceTimeout);
+                }
+            },
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Cleanup
+    // -------------------------------------------------------------------------
+    async cleanup(maxAgeDays = DEFAULT_RETENTION_DAYS) {
+        const result = { deletedCount: 0, freedBytes: 0, errors: [] };
+        const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+        try {
+            const artifacts = await this.listArtifacts();
+            for (const artifact of artifacts) {
+                if (artifact.modifiedAt.getTime() < cutoff) {
+                    try {
+                        await vscode.workspace.fs.delete(artifact.uri);
+                        result.deletedCount++;
+                        result.freedBytes += artifact.size;
+                    }
+                    catch (err) {
+                        result.errors.push(`Failed to delete ${artifact.filename}: ${err}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            result.errors.push(`Cleanup failed: ${err}`);
+        }
+        if (result.deletedCount > 0) {
+            this.outputChannel.appendLine(`[ArtifactManager] Cleaned up ${result.deletedCount} artifacts (${(result.freedBytes / 1024).toFixed(1)} KB)`);
+        }
+        return result;
+    }
+    // -------------------------------------------------------------------------
+    // Manifest Management
+    // -------------------------------------------------------------------------
+    async getManifestUri() {
+        const base = await this.ensureArtifactDir();
+        return vscode.Uri.joinPath(base, 'manifest.json');
+    }
+    async getManifest() {
+        try {
+            const uri = await this.getManifestUri();
+            const content = await vscode.workspace.fs.readFile(uri);
+            return JSON.parse(Buffer.from(content).toString('utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveManifest(manifest) {
+        const uri = await this.getManifestUri();
+        const content = JSON.stringify(manifest, null, 2);
+        await vscode.workspace.fs.writeFile(uri, Buffer.from(content, 'utf-8'));
+    }
+    async addToManifest(entry) {
+        let manifest = await this.getManifest();
+        if (!manifest) {
+            manifest = {
+                version: 1,
+                generatedAt: new Date().toISOString(),
+                dataHash: '',
+                prompt: '',
+                artifacts: [],
+            };
+        }
+        // Remove existing entry with same filename if present
+        manifest.artifacts = manifest.artifacts.filter(a => a.filename !== entry.filename);
+        manifest.artifacts.push(entry);
+        await this.saveManifest(manifest);
+    }
+    // -------------------------------------------------------------------------
+    // Disposal
+    // -------------------------------------------------------------------------
+    dispose() {
+        this.watcher?.dispose();
+        if (this.debounceTimeout) {
+            clearTimeout(this.debounceTimeout);
+        }
+    }
+}
+exports.ArtifactManagerImpl = ArtifactManagerImpl;

package/out/analytics/dashboard/fleetDisplayUtils.js

@@ -0,0 +1,159 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScheduleHintsByChatSessionId = buildScheduleHintsByChatSessionId;
+exports.inferFleetEngineId = inferFleetEngineId;
+exports.formatFleetModelLabel = formatFleetModelLabel;
+exports.formatFleetEngineLabel = formatFleetEngineLabel;
+exports.fleetEngineIdToChatModeName = fleetEngineIdToChatModeName;
+exports.enrichFleetRowMetadata = enrichFleetRowMetadata;
+const AGENTIDE_MODEL_PREFIX = 'agentide-';
+function buildScheduleHintsByChatSessionId(scheduled) {
+    const map = new Map();
+    for (const item of scheduled) {
+        const sessionId = String(item.sessionId ?? '').trim();
+        if (!sessionId) {
+            continue;
+        }
+        map.set(sessionId, {
+            model: item.model,
+            engine: item.engine,
+            agentId: item.agentId,
+        });
+    }
+    return map;
+}
+/** Infer agent engine id from stored model key (e.g. agentide-cursor::auto → cursor). */
+function inferFleetEngineId(model, engine) {
+    const engineTrim = String(engine ?? '').trim();
+    if (engineTrim) {
+        return engineTrim;
+    }
+    const raw = String(model ?? '').trim().toLowerCase();
+    if (!raw || raw === 'unknown' || raw === 'scheduled') {
+        return '';
+    }
+    if (raw.includes('cursor')) {
+        return 'cursor';
+    }
+    if (raw.includes('codex') || raw.includes('openai-codex')) {
+        return 'codex';
+    }
+    if (raw.includes('claude')) {
+        return 'claude';
+    }
+    if (raw.includes('openclaw') || raw.includes('grok')) {
+        if (raw.includes('grok')) {
+            return 'grok';
+        }
+        return 'openclaw';
+    }
+    if (raw.startsWith('agentide-litellm::')) {
+        return '';
+    }
+    const vendor = raw.startsWith(AGENTIDE_MODEL_PREFIX)
+        ? raw.slice(AGENTIDE_MODEL_PREFIX.length).split('::')[0]
+        : raw.split('::')[0];
+    if (vendor && vendor !== 'litellm' && vendor !== 'unknown') {
+        return vendor;
+    }
+    return '';
+}
+/** Human-readable model label for fleet cards (keeps raw id in row.model for chat restore). */
+function formatFleetModelLabel(model, engine) {
+    const raw = String(model ?? '').trim();
+    if (!raw || raw === 'unknown' || raw === 'scheduled') {
+        const engineId = inferFleetEngineId(undefined, engine);
+        if (engineId === 'cursor') {
+            return 'Cursor Auto';
+        }
+        if (engineId) {
+            return formatFleetEngineLabel(engineId);
+        }
+        return '—';
+    }
+    if (raw.startsWith('agentide-cursor::')) {
+        const tail = raw.slice('agentide-cursor::'.length).trim() || 'auto';
+        if (tail === 'auto') {
+            return 'Cursor Auto';
+        }
+        return `Cursor ${tail}`;
+    }
+    if (raw.startsWith(AGENTIDE_MODEL_PREFIX)) {
+        const inner = raw.slice(AGENTIDE_MODEL_PREFIX.length);
+        const sep = inner.indexOf('::');
+        if (sep >= 0) {
+            const tail = inner.slice(sep + 2);
+            if (tail) {
+                return tail;
+            }
+        }
+    }
+    return raw;
+}
+function formatFleetEngineLabel(model, engine) {
+    const engineId = inferFleetEngineId(model, engine);
+    if (!engineId) {
+        return '—';
+    }
+    return engineId.charAt(0).toUpperCase() + engineId.slice(1);
+}
+/** Chat mode name for workbench.action.chat.open from a fleet engine id (e.g. cursor → Agent Cursor). */
+function fleetEngineIdToChatModeName(engine) {
+    const engineId = String(engine ?? '').trim();
+    if (!engineId) {
+        return undefined;
+    }
+    const displayName = engineId.charAt(0).toUpperCase() + engineId.slice(1);
+    return `Agent ${displayName}`;
+}
+function isMissingFleetModel(model) {
+    const raw = String(model ?? '').trim();
+    return !raw || raw === 'unknown' || raw === 'scheduled';
+}
+function isMissingFleetEngine(engine) {
+    return !String(engine ?? '').trim();
+}
+/** Apply schedule hints and model-based engine inference to a fleet row. */
+function enrichFleetRowMetadata(row, scheduleHint) {
+    if (scheduleHint) {
+        if (isMissingFleetModel(row.model) && scheduleHint.model) {
+            row.model = scheduleHint.model;
+        }
+        if (isMissingFleetEngine(row.engine)) {
+            row.engine = scheduleHint.engine || inferFleetEngineId(scheduleHint.model);
+        }
+        if (!row.agentId && scheduleHint.agentId) {
+            row.agentId = scheduleHint.agentId;
+        }
+    }
+    const title = String(row.taskTitle ?? row.cardTitle ?? '').toLowerCase();
+    if (isMissingFleetModel(row.model)) {
+        if (title.includes('cursor')) {
+            row.model = 'agentide-cursor::auto';
+            row.engine = row.engine || 'cursor';
+        }
+        else if (title.includes('codex')) {
+            row.engine = row.engine || 'codex';
+        }
+        else if (title.includes('claude')) {
+            row.engine = row.engine || 'claude';
+        }
+    }
+    if (isMissingFleetEngine(row.engine)) {
+        if (title.includes('cursor')) {
+            row.engine = 'cursor';
+        }
+        else if (title.includes('codex')) {
+            row.engine = 'codex';
+        }
+        else if (title.includes('claude')) {
+            row.engine = 'claude';
+        }
+        else {
+            row.engine = inferFleetEngineId(row.model, row.engine);
+        }
+    }
+}