@agenthippo-ai/agenthippo 0.1.0

package/out/store/github/setup.js

@@ -0,0 +1,235 @@
+"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.setupStoreAutomation = setupStoreAutomation;
+exports.triggerStoreWorkflow = triggerStoreWorkflow;
+/**
+ * Store Setup
+ *
+ * Automates the setup of AgentHippo store index automation in a GitHub repository.
+ * Creates the necessary GitHub Action workflow and build scripts via a pull request.
+ */
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const github_1 = require("../../agentpack/github");
+const utils_1 = require("../../utils");
+// Helper to conditionally log
+function log(logger, msg) {
+    if (logger) {
+        (0, utils_1.logInfo)(logger, msg);
+    }
+}
+// -----------------------------------------------------------------------------
+// Template Loading
+// -----------------------------------------------------------------------------
+/**
+ * Get the path to the templates folder.
+ * Templates are in the same directory as this file (src/store/github/templates or out/store/github/templates).
+ */
+function getTemplatesDir() {
+    return path.join(__dirname, 'templates');
+}
+/**
+ * Load a template file from the templates folder.
+ */
+async function loadTemplate(filename) {
+    const templatePath = path.join(getTemplatesDir(), filename);
+    return await fs_1.promises.readFile(templatePath, 'utf8');
+}
+/**
+ * Set up store index automation in a GitHub repository.
+ * Creates a pull request with the workflow file, build script, and package.json.
+ */
+async function setupStoreAutomation(owner, repo, outputChannel) {
+    const filesCreated = [];
+    try {
+        // Verify we have access to the repo (needs workflow scope to write .github/workflows)
+        await (0, github_1.getGitHubToken)(true, ['repo', 'user', 'workflow']);
+        const [repoInfo, currentUser] = await Promise.all([
+            (0, github_1.getRepo)(owner, repo),
+            (0, github_1.getGitHubUser)(),
+        ]);
+        if (!repoInfo) {
+            return {
+                success: false,
+                message: `Repository ${owner}/${repo} not found or not accessible`,
+                filesCreated: [],
+            };
+        }
+        // Check if user has write access (must be owner or collaborator)
+        const isOwner = repoInfo.owner.login.toLowerCase() === currentUser.login.toLowerCase();
+        if (!isOwner) {
+            return {
+                success: false,
+                message: `You don't have write access to ${owner}/${repo}. You must be the repository owner to set up store automation.`,
+                filesCreated: [],
+            };
+        }
+        log(outputChannel, `[AgentHippo] Setting up store automation for ${owner}/${repo}...`);
+        // Get the default branch and check if repo has commits
+        let defaultBranch;
+        try {
+            defaultBranch = await (0, github_1.getDefaultBranch)(owner, repo);
+            log(outputChannel, `[AgentHippo] Default branch: ${defaultBranch}`);
+        }
+        catch (e) {
+            return {
+                success: false,
+                message: `Repository ${owner}/${repo} appears to be empty (no commits). Please create an initial commit first (e.g., add a README).`,
+                filesCreated: [],
+            };
+        }
+        // Create a unique branch name (no slashes to avoid API issues)
+        const timestamp = Date.now();
+        const branchName = `agenthippo-store-setup-${timestamp}`;
+        // Create branch from default
+        log(outputChannel, `[AgentHippo] Creating branch: ${branchName}`);
+        await (0, github_1.createBranch)(owner, repo, branchName, defaultBranch);
+        // Load templates
+        const [workflowContent, scriptContent, packageContent] = await Promise.all([
+            loadTemplate('build-index.yml'),
+            loadTemplate('build-index.ts'),
+            loadTemplate('package.json'),
+        ]);
+        // Prepare files to commit
+        const filesToCommit = [
+            { path: '.github/workflows/build-index.yml', content: workflowContent },
+            { path: 'scripts/build-index.ts', content: scriptContent },
+        ];
+        filesCreated.push('.github/workflows/build-index.yml', 'scripts/build-index.ts');
+        // Only add package.json if it doesn't exist
+        const existingPackage = await (0, github_1.getFileContent)(owner, repo, 'package.json').catch(() => null);
+        if (!existingPackage) {
+            filesToCommit.push({ path: 'package.json', content: packageContent });
+            filesCreated.push('package.json');
+        }
+        // Commit all files in a single commit
+        log(outputChannel, `[AgentHippo] Committing ${filesToCommit.length} files...`);
+        await (0, github_1.commitMultipleFiles)(owner, repo, branchName, filesToCommit, 'chore: add AgentHippo store index automation', { scopes: ['repo', 'user', 'workflow'] });
+        for (const file of filesToCommit) {
+            // allow-any-unicode-next-line
+            log(outputChannel, `[AgentHippo]   ✓ ${file.path}`);
+        }
+        if (existingPackage) {
+            log(outputChannel, `[AgentHippo]   - package.json (already exists)`);
+        }
+        // Create pull request
+        log(outputChannel, `[AgentHippo] Creating pull request...`);
+        const pr = await (0, github_1.createPullRequest)(owner, repo, {
+            // allow-any-unicode-next-line
+            title: '🦛 Add AgentHippo Store Index Automation',
+            body: `## What's this?
+
+This PR adds automated store index building for AgentHippo.
+
+### Files added:
+${filesCreated.map(f => `- \`${f}\``).join('\n')}
+
+### What happens next?
+
+1. **Merge this PR** to enable the automation
+2. The GitHub Action will build the Orama search index on every push to \`${defaultBranch}\`
+3. The index is committed to \`dist/\` and deployed to GitHub Pages (if enabled)
+
+### How it works
+
+| Repo Type | Primary Source | Fallback |
+|-----------|----------------|----------|
+| **Public** | GitHub Pages (CDN) | GitHub API |
+| **Private** | GitHub API | - |
+
+### Optional: Enable GitHub Pages (public repos)
+
+For faster index loading on public repos:
+1. Go to Settings → Pages
+2. Set Source to "GitHub Actions"
+
+---
+*Generated by [AgentHippo](https://github.com/agenthippoai/agentide)*`,
+            head: branchName,
+            base: defaultBranch,
+        });
+        // allow-any-unicode-next-line
+        log(outputChannel, `[AgentHippo] ✅ Pull request created: ${pr.html_url}`);
+        return {
+            success: true,
+            message: `Pull request #${pr.number} created successfully!`,
+            filesCreated,
+            pullRequestUrl: pr.html_url,
+            pullRequestNumber: pr.number,
+        };
+    }
+    catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        // allow-any-unicode-next-line
+        log(outputChannel, `[AgentHippo] ❌ Error: ${errorMsg}`);
+        return {
+            success: false,
+            message: errorMsg,
+            filesCreated,
+        };
+    }
+}
+/**
+ * Trigger the store index workflow manually.
+ */
+async function triggerStoreWorkflow(owner, repo, outputChannel) {
+    try {
+        const token = await (0, github_1.getGitHubToken)();
+        const defaultBranch = await (0, github_1.getDefaultBranch)(owner, repo);
+        const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/actions/workflows/build-index.yml/dispatches`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ ref: defaultBranch }),
+        });
+        if (response.ok || response.status === 204) {
+            log(outputChannel, `[AgentHippo] Workflow triggered successfully`);
+            return true;
+        }
+        log(outputChannel, `[AgentHippo] Failed to trigger workflow: ${response.status}`);
+        return false;
+    }
+    catch (e) {
+        log(outputChannel, `[AgentHippo] Error triggering workflow: ${e}`);
+        return false;
+    }
+}

package/out/store/github/templates/build-index.ts

@@ -0,0 +1,339 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+// @ts-nocheck - This is a template file, not compiled by the extension
+// To make this file executable, add: #!/usr/bin/env bun
+/**
+ * Store Index Builder - Auto-generated by AgentHippo
+ *
+ * Scans agent-packs/, skills/, mcp/, engines/, and spotlight/ and builds an Orama search index.
+ * Run with: bun run scripts/build-index.ts
+ */
+
+import { readdir, readFile, writeFile, mkdir, stat } from 'fs/promises';
+import { join, basename } from 'path';
+import { parse as parseYaml } from 'yaml';
+
+// -----------------------------------------------------------------------------
+// Configuration
+// -----------------------------------------------------------------------------
+
+const ARTIFACT_DIRS = {
+	pack: 'agent-packs',
+	skill: 'skills',
+	mcp: 'mcp',
+	engine: 'engines',
+	view: 'spotlight',
+} as const;
+
+const OUTPUT_DIR = 'dist';
+
+// -----------------------------------------------------------------------------
+// Types
+// -----------------------------------------------------------------------------
+
+interface StoreArtifact {
+	id: string;
+	type: 'pack' | 'skill' | 'mcp' | 'engine' | 'view';
+	slug: string;
+	displayName: string;
+	description: string;
+	tags: string[];
+	author?: string;
+	latestVersion: string;
+	updatedAt: string;
+}
+
+// -----------------------------------------------------------------------------
+// Parsers
+// -----------------------------------------------------------------------------
+
+function parseFrontmatter(content: string): Record<string, unknown> {
+	if (!content.startsWith('---')) {
+		return {};
+	}
+	const lines = content.split('\n');
+	let endIndex = -1;
+	for (let i = 1; i < lines.length; i++) {
+		if (lines[i].trim() === '---') {
+			endIndex = i;
+			break;
+		}
+	}
+	if (endIndex === -1) {
+		return {};
+	}
+	try {
+		return parseYaml(lines.slice(1, endIndex).join('\n')) as Record<string, unknown>;
+	} catch {
+		return {};
+	}
+}
+
+async function parseSkill(dir: string): Promise<StoreArtifact | null> {
+	const slug = basename(dir);
+	try {
+		const content = await readFile(join(dir, 'SKILL.md'), 'utf8');
+		const fm = parseFrontmatter(content);
+		const stats = await stat(join(dir, 'SKILL.md'));
+		return {
+			id: `skill/${slug}`,
+			type: 'skill',
+			slug,
+			displayName: (fm.name as string) || slug,
+			description: (fm.description as string) || '',
+			tags: (fm.tags as string[]) || [],
+			author: fm.author as string | undefined,
+			latestVersion: (fm.version as string) || '0.0.0',
+			updatedAt: stats.mtime.toISOString(),
+		};
+	} catch {
+		return null;
+	}
+}
+
+async function parsePack(dir: string): Promise<StoreArtifact | null> {
+	const slug = basename(dir);
+	try {
+		const content = await readFile(join(dir, 'agent.yaml'), 'utf8');
+		const manifest = parseYaml(content) as Record<string, unknown>;
+		const meta = (manifest.metadata as Record<string, unknown>) || {};
+		const stats = await stat(join(dir, 'agent.yaml'));
+		return {
+			id: `pack/${slug}`,
+			type: 'pack',
+			slug,
+			displayName: (meta.name as string) || slug,
+			description: (meta.description as string) || '',
+			tags: (meta.tags as string[]) || [],
+			author: meta.author as string | undefined,
+			latestVersion: (meta.version as string) || '0.0.0',
+			updatedAt: stats.mtime.toISOString(),
+		};
+	} catch {
+		return null;
+	}
+}
+
+async function parseMcp(dir: string): Promise<StoreArtifact | null> {
+	const slug = basename(dir);
+	try {
+		const content = await readFile(join(dir, 'mcp.json'), 'utf8');
+		const manifest = JSON.parse(content) as Record<string, unknown>;
+		const stats = await stat(join(dir, 'mcp.json'));
+		return {
+			id: `mcp/${slug}`,
+			type: 'mcp',
+			slug,
+			displayName: (manifest.name as string) || slug,
+			description: (manifest.description as string) || '',
+			tags: (manifest.tags as string[]) || [],
+			author: manifest.author as string | undefined,
+			latestVersion: (manifest.version as string) || '0.0.0',
+			updatedAt: stats.mtime.toISOString(),
+		};
+	} catch {
+		return null;
+	}
+}
+
+function resolveViewPublishVersion(manifest: Record<string, unknown>): string | undefined {
+	if (typeof manifest.version === 'string' && manifest.version.trim()) {
+		return manifest.version.trim().replace(/^v/, '');
+	}
+	if (typeof manifest.semver === 'string' && manifest.semver.trim()) {
+		return manifest.semver.trim().replace(/^v/, '');
+	}
+	return undefined;
+}
+
+async function parseView(dir: string): Promise<StoreArtifact | null> {
+	const slug = basename(dir);
+	try {
+		const content = await readFile(join(dir, 'view.yaml'), 'utf8');
+		const manifest = parseYaml(content) as Record<string, unknown>;
+		const stats = await stat(join(dir, 'view.yaml'));
+		const tags = Array.isArray(manifest.tags)
+			? (manifest.tags as string[])
+			: [];
+		return {
+			id: `view/${slug}`,
+			type: 'view',
+			slug,
+			displayName: (manifest.name as string) || slug,
+			description: (manifest.description as string) || '',
+			tags: ['spotlight', ...tags],
+			author: manifest.author as string | undefined,
+			latestVersion: resolveViewPublishVersion(manifest) || '0.0.0',
+			updatedAt: stats.mtime.toISOString(),
+		};
+	} catch {
+		return null;
+	}
+}
+
+async function parseEngine(dir: string): Promise<StoreArtifact | null> {
+	const slug = basename(dir);
+	try {
+		const content = await readFile(join(dir, 'engine.manifest.json'), 'utf8');
+		const manifest = JSON.parse(content) as Record<string, unknown>;
+		const stats = await stat(join(dir, 'engine.manifest.json'));
+		const packageJson = await readFile(join(dir, 'package.json'), 'utf8')
+			.then(raw => JSON.parse(raw) as Record<string, unknown>)
+			.catch(() => undefined);
+		const model = manifest.model as Record<string, unknown> | undefined;
+		const defaultModel = typeof model?.defaultModel === 'string'
+			? model.defaultModel
+			: typeof model?.default === 'string'
+				? model.default
+				: undefined;
+		return {
+			id: `engine/${slug}`,
+			type: 'engine',
+			slug,
+			displayName: (manifest.displayName as string) || (manifest.id as string) || slug,
+			description: (manifest.description as string) || '',
+			tags: ['engine', defaultModel].filter(Boolean) as string[],
+			author: manifest.author as string | undefined,
+			latestVersion: (packageJson?.version as string) || '0.0.0',
+			updatedAt: stats.mtime.toISOString(),
+		};
+	} catch {
+		return null;
+	}
+}
+
+// -----------------------------------------------------------------------------
+// Main
+// -----------------------------------------------------------------------------
+
+async function buildIndex() {
+	// allow-any-unicode-next-line
+	console.log('🦛 AgentHippo Store Index Builder');
+	// allow-any-unicode-next-line
+	console.log('──────────────────────────────────');
+	console.log('');
+
+	const artifacts: StoreArtifact[] = [];
+
+	for (const [type, dir] of Object.entries(ARTIFACT_DIRS)) {
+		let entries: string[] = [];
+		try {
+			entries = await readdir(dir);
+		} catch {
+			// allow-any-unicode-next-line
+			console.log(`📁 ${dir}/ not found, skipping...`);
+			continue;
+		}
+
+		// allow-any-unicode-next-line
+		console.log(`📁 Scanning ${dir}/`);
+		for (const entry of entries) {
+			if (entry.startsWith('.')) {
+				continue;
+			}
+			const path = join(dir, entry);
+			const s = await stat(path).catch(() => null);
+			if (!s?.isDirectory()) {
+				continue;
+			}
+
+			let artifact: StoreArtifact | null = null;
+			if (type === 'skill') {
+				artifact = await parseSkill(path);
+			} else if (type === 'pack') {
+				artifact = await parsePack(path);
+			} else if (type === 'mcp') {
+				artifact = await parseMcp(path);
+			} else if (type === 'engine') {
+				artifact = await parseEngine(path);
+			} else if (type === 'view') {
+				artifact = await parseView(path);
+			}
+
+			if (artifact) {
+				artifacts.push(artifact);
+				// allow-any-unicode-next-line
+				console.log(`   ✓ ${artifact.displayName} (${artifact.slug})`);
+			}
+		}
+	}
+
+	console.log('');
+	// allow-any-unicode-next-line
+	console.log(`📦 Building index with ${artifacts.length} artifacts...`);
+
+	await mkdir(OUTPUT_DIR, { recursive: true });
+
+	// Main index for Orama
+	const index = {
+		version: 1,
+		generatedAt: new Date().toISOString(),
+		generator: 'AgentHippo Store Index Builder',
+		artifacts,
+	};
+
+	await writeFile(join(OUTPUT_DIR, 'store-index.json'), JSON.stringify(index, null, 2));
+	await writeFile(join(OUTPUT_DIR, 'store-orama.json'), JSON.stringify({ artifacts }));
+	await writeFile(
+		join(OUTPUT_DIR, 'store-meta.json'),
+		JSON.stringify(
+			{
+				version: 1,
+				generatedAt: new Date().toISOString(),
+				artifactCount: artifacts.length,
+			},
+			null,
+			2,
+		),
+	);
+
+	// Create a simple index.html for GitHub Pages landing
+	await writeFile(
+		join(OUTPUT_DIR, 'index.html'),
+		`<!DOCTYPE html>
+<html>
+<head>
+	<title>AgentHippo Store Index</title>
+	<meta charset="utf-8">
+	<style>
+		body { font-family: system-ui; max-width: 600px; margin: 2rem auto; padding: 1rem; }
+		h1 { display: flex; align-items: center; gap: 0.5rem; }
+		a { color: #0969da; }
+		code { background: #f6f8fa; padding: 0.2em 0.4em; border-radius: 3px; }
+	</style>
+</head>
+<body>
+	` + /* allow-any-unicode-next-line */ `
+	<h1>🦛 AgentHippo Store Index</h1>
+	<p>This is the search index for the AgentHippo extension store.</p>
+	<ul>
+		<li><a href="store-index.json">store-index.json</a> - Full artifact metadata</li>
+		<li><a href="store-orama.json">store-orama.json</a> - Orama search index</li>
+		<li><a href="store-meta.json">store-meta.json</a> - Index metadata</li>
+	</ul>
+	<p>Generated: ${new Date().toISOString()}</p>
+	<p>Artifacts: ${artifacts.length}</p>
+</body>
+</html>`,
+	);
+
+	console.log('');
+	// allow-any-unicode-next-line
+	console.log('✅ Index built successfully!');
+	// allow-any-unicode-next-line
+	console.log(`   📄 ${OUTPUT_DIR}/store-index.json`);
+	// allow-any-unicode-next-line
+	console.log(`   📄 ${OUTPUT_DIR}/store-orama.json`);
+	// allow-any-unicode-next-line
+	console.log(`   📄 ${OUTPUT_DIR}/store-meta.json`);
+	// allow-any-unicode-next-line
+	console.log(`   📄 ${OUTPUT_DIR}/index.html`);
+}
+
+buildIndex().catch((e) => {
+	// allow-any-unicode-next-line
+	console.error('❌ Build failed:', e);
+	process.exit(1);
+});

package/out/store/github/templates/build-index.yml

@@ -0,0 +1,97 @@
+# AgentHippo Store Index Builder
+# Auto-generated by AgentHippo extension
+#
+# This workflow builds the Orama search index.
+# - Public repos: Deploys to GitHub Pages (fast CDN)
+# - All repos: Commits index to dist/ (fallback for private repos)
+
+name: Build Store Index
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'agent-packs/**'
+      - 'skills/**'
+      - 'mcp/**'
+      - 'engines/**'
+      - 'spotlight/**'
+      - 'scripts/build-index.ts'
+      - 'package.json'
+      - '.github/workflows/build-index.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "store-index"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    outputs:
+      has_artifacts: ${{ steps.build.outputs.has_artifacts }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Build index
+        id: build
+        run: |
+          bun run scripts/build-index.ts
+          if [ -f "dist/store-index.json" ]; then
+            echo "has_artifacts=true" >> $GITHUB_OUTPUT
+          else
+            echo "has_artifacts=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Commit index to repository
+        if: steps.build.outputs.has_artifacts == 'true'
+        continue-on-error: true
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add dist/
+          if git diff --staged --quiet; then
+            echo "No dist changes staged (e.g. dist/ is gitignored); skipping commit."
+          else
+            git commit -m "chore: update store index [skip ci]"
+            git push
+          fi
+
+      - name: Setup Pages
+        if: steps.build.outputs.has_artifacts == 'true'
+        uses: actions/configure-pages@v4
+        continue-on-error: true
+
+      - name: Upload Pages artifact
+        if: steps.build.outputs.has_artifacts == 'true'
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: './dist'
+        continue-on-error: true
+
+  deploy-pages:
+    runs-on: ubuntu-latest
+    needs: build
+    if: needs.build.outputs.has_artifacts == 'true'
+    continue-on-error: true  # Don't fail if Pages not available (private repos)
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

package/out/store/github/templates/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "agenthippo-store",
+  "private": true,
+  "scripts": {
+    "build": "bun run scripts/build-index.ts"
+  },
+  "dependencies": {
+    "yaml": "^2.7.1"
+  }
+}
+