@ninemind/agentgem 0.1.0

package/dist/gem.controller.js

@@ -0,0 +1,518 @@
+import { __decorate, __metadata } from "tslib";
+// src/gem.controller.ts
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import { api, get, post } from "@agentback/openapi";
+import { introspectConfig, introspectProject } from "./gem/introspect.js";
+import { buildGem } from "./gem/buildGem.js";
+import { scaffoldChecks } from "./gem/checks.js";
+import { materialize, compatibility } from "./gem/targets.js";
+import { DEPLOY_REGISTRY, deployTargetList } from "./gem/deploy.js";
+import { createWorkspace, listWorkspaces, readWorkspace, renderTarget, deleteWorkspace } from "./gem/workspaces.js";
+import { writeGemArchive, readGemArchive } from "./gem/archive.js";
+import { writeArchiveDir, readArchiveDir } from "./gem/archiveFs.js";
+import { packTar } from "./gem/archiveTar.js";
+import { readDeployRecord, writeDeployRecord, clearDeployRecord } from "./gem/deployRecord.js";
+import { undeployManagedAgent, anthropicPublishClient } from "./publish.js";
+import { undeployAgentcoreHarness, realAgentcoreControlClient } from "./gem/agentcorePublish.js";
+import { InventorySchema, GemSchema, GemRequestSchema, DirQuerySchema, PickQuerySchema, PickFolderSchema, ScaffoldChecksRequestSchema, ScaffoldChecksResponseSchema, MaterializeRequestSchema, MaterializeResponseSchema, PublishPreviewRequestSchema, PublishRequestSchema, PublishPreviewResponseSchema, PublishReadyResponseSchema, PublishResultSchema, DeployTargetsResponseSchema, DeployReadyQuerySchema, ArchiveRequestSchema, ArchiveResponseSchema, CreateWorkspaceRequestSchema, WorkspaceQuerySchema, RenderRequestSchema, WorkspaceNameRequestSchema, WorkspaceSummarySchema, WorkspaceDetailSchema, RenderResultSchema, ListWorkspacesResponseSchema, DeleteWorkspaceResponseSchema, RunReadyQuerySchema, RunReadyResponseSchema, RunRequestSchema, RunStatusQuerySchema, RunStateSchema, RunStopRequestSchema, RunStopResponseSchema, CredentialRequestSchema, CredentialResponseSchema, TestbedDetectQuerySchema, TestbedDetectResponseSchema, TestbedSuggestionQuerySchema, TestbedSuggestionResponseSchema, TestbedRecentsResponseSchema, TestbedProjectsQuerySchema, TestbedProjectsResponseSchema, TestbedScaffoldRequestSchema, TestbedScaffoldResponseSchema, TestbedImportRequestSchema, TestbedImportResponseSchema, AgentcoreReadyResponseSchema, AgentcoreDeployRequestSchema, AgentcoreStatusQuerySchema, AgentcoreDeployStateSchema, RegistryReadyResponseSchema, RegistryIndexResponseSchema, RegistryResolveRequestSchema, RegistryResolveResponseSchema, RegistryInstallRequestSchema, RegistryInstallResponseSchema, RegistryPublishRequestSchema, RegistryPublishResponseSchema, UndeployRequestSchema, UndeployResponseSchema, DeployRecordQuerySchema, DeployRecordResponseSchema, } from "./schemas.js";
+import { runReadiness, startLocal, stopLocal, getRunStatus, deployVercel, deployCloudflare, undeployVercel, undeployCloudflare } from "./gem/run.js";
+import { setCredential } from "./gem/credentials.js";
+import { agentcoreReadiness, deployAgentcore, getAgentcoreStatus } from "./gem/agentcoreRun.js";
+import { scaffoldTestbed, importArtifacts } from "./gem/testbed.js";
+import { detectFlavor, suggestTestbed, discoverProjects } from "./gem/testbedFlavors.js";
+import { readRecents, upsertRecent } from "./gem/recents.js";
+import { resolveInstall, publishGem } from "./gem/registry.js";
+import { githubRegistrySource, githubRegistryPublisher, registryConfigFromEnv, registryReady } from "./gem/registryGithub.js";
+import { resolveDirs, resolveProject, agentgemHome } from "./resolveDir.js";
+import { pickFolder } from "./pickFolder.js";
+let GemController = class GemController {
+    async inventory(input) {
+        return introspectAll(input.query.dir, parseProjectsQuery(input.query.projects));
+    }
+    async gem(input) {
+        const dirs = resolveDirs(input.body.dir);
+        const inventory = introspectAll(input.body.dir, input.body.projects);
+        return buildGem(inventory, input.body.selection, {
+            name: input.body.name ?? "gem",
+            createdFrom: dirs.claudeDir,
+            checks: input.body.checks,
+        });
+    }
+    async scaffoldChecks(input) {
+        const dirs = resolveDirs(input.body.dir);
+        const inventory = introspectAll(input.body.dir, input.body.projects);
+        const gem = buildGem(inventory, input.body.selection, { name: input.body.name ?? "gem", createdFrom: dirs.claudeDir });
+        return { checks: scaffoldChecks(gem) };
+    }
+    async materialize(input) {
+        const target = input.body.target;
+        let gem;
+        if (input.body.archivePath) {
+            gem = readGemArchive(readArchiveDir(input.body.archivePath));
+        }
+        else {
+            const dirs = resolveDirs(input.body.dir);
+            const inventory = introspectAll(input.body.dir, input.body.projects);
+            gem = buildGem(inventory, input.body.selection, { name: input.body.name ?? "gem", createdFrom: dirs.claudeDir });
+        }
+        return { target, ...materialize(gem, target), compatibility: compatibility(gem) };
+    }
+    async archive(input) {
+        const dirs = resolveDirs(input.body.dir);
+        const inventory = introspectAll(input.body.dir, input.body.projects);
+        const gem = buildGem(inventory, input.body.selection, { name: input.body.name ?? "gem", createdFrom: dirs.claudeDir });
+        const { files, skipped } = writeGemArchive(gem, { version: input.body.version });
+        const lock = JSON.parse(files["gem.lock"]);
+        let path = null;
+        if (input.body.outDir) {
+            writeArchiveDir(input.body.outDir, files);
+            path = input.body.outDir;
+        }
+        const tarGz = input.body.tar ? packTar(files).toString("base64") : null;
+        return { files, lock, skipped, path, tarGz };
+    }
+    async createWorkspace(input) {
+        const dirs = resolveDirs(input.body.dir);
+        const inventory = introspectAll(input.body.dir, input.body.projects);
+        const gem = buildGem(inventory, input.body.selection, { name: input.body.name, createdFrom: dirs.claudeDir });
+        return createWorkspace(input.body.name, gem, { version: input.body.version });
+    }
+    async listWorkspaces(_input) {
+        return { workspaces: listWorkspaces() };
+    }
+    async readWorkspace(input) {
+        return readWorkspace(input.query.name);
+    }
+    async renderWorkspace(input) {
+        return renderTarget(input.body.name, input.body.target);
+    }
+    async deleteWorkspace(input) {
+        deleteWorkspace(input.body.name);
+        return { deleted: input.body.name };
+    }
+    // Whether the server is configured to run/deploy the rendered eve project. Booleans only.
+    async runReady(_input) {
+        return runReadiness();
+    }
+    // OUTWARD-FACING (local machine): set + persist a server-side deploy/publish credential
+    // (allowlisted keys only) to ~/.agentgem/.env. The value is never logged or returned.
+    async credential(input) {
+        setCredential(input.body.key, input.body.value);
+        return { ok: true };
+    }
+    // OUTWARD-FACING (local machine): run the rendered eve project locally or deploy it to Vercel.
+    async run(input) {
+        const { name, mode } = input.body;
+        const state = mode === "cloudflare" ? await deployCloudflare(name) : mode === "vercel" ? await deployVercel(name, undefined, { eveAuth: input.body.eveAuth }) : await startLocal(name);
+        return state;
+    }
+    async runStatus(input) {
+        return getRunStatus(input.query.name, input.query.target);
+    }
+    async runStop(input) {
+        return stopLocal(input.body.name, input.body.target);
+    }
+    async agentcoreDeployReady(_input) {
+        return agentcoreReadiness();
+    }
+    // OUTWARD-FACING: shells the agentcore CLI to deploy the workspace's rendered project to AWS.
+    async agentcoreDeploy(input) {
+        return deployAgentcore(input.body.name);
+    }
+    async agentcoreDeployStatus(input) {
+        return getAgentcoreStatus(input.query.name);
+    }
+    async deployTargets(_input) {
+        return { targets: deployTargetList() };
+    }
+    // Offline render of the deploy payload + skip/secret/skill lists. No network.
+    async publishPreview(input) {
+        const dirs = resolveDirs(input.body.dir);
+        const inventory = introspectAll(input.body.dir, input.body.projects);
+        const gem = buildGem(inventory, input.body.selection, { name: input.body.name ?? "gem", createdFrom: dirs.claudeDir });
+        const target = (input.body.target ?? "claude-managed");
+        return DEPLOY_REGISTRY[target].preview(gem);
+    }
+    // Whether the server is configured for the deploy backend (the UI gates on this). Boolean only.
+    async publishReady(input) {
+        const target = (input.query.target ?? "claude-managed");
+        return { ready: DEPLOY_REGISTRY[target].ready() };
+    }
+    // OUTWARD-FACING: gated network deploy through the selected backend. The key is read server-side
+    // (inside the registry's deploy) and never returned; only the redacted gem payload is sent.
+    async publish(input) {
+        const dirs = resolveDirs(input.body.dir);
+        const inventory = introspectAll(input.body.dir, input.body.projects);
+        const gem = buildGem(inventory, input.body.selection, { name: input.body.name ?? "gem", createdFrom: dirs.claudeDir });
+        const target = (input.body.target ?? "claude-managed");
+        const result = await DEPLOY_REGISTRY[target].deploy(gem, input.body.requestId);
+        if (input.body.wsName) {
+            const at = new Date().toISOString();
+            if (result.kind === "managed-agent") {
+                writeDeployRecord(input.body.wsName, {
+                    backend: "claude-managed", at,
+                    agentId: result.agentId, environmentId: result.environmentId,
+                    skillIds: result.registeredSkills.map((s) => s.skillId),
+                });
+            }
+            else if (result.kind === "agentcore-harness") {
+                writeDeployRecord(input.body.wsName, { backend: "agentcore", at, harnessId: result.harnessId });
+            }
+        }
+        return result;
+    }
+    async undeploy(input) {
+        const { name, target } = input.body;
+        if (target === "eve") {
+            const r = await undeployVercel(name);
+            if (!r.removed)
+                throw new Error(`Vercel undeploy failed for "${name}". Check logs.`);
+            return { removed: true, logTail: r.logTail };
+        }
+        if (target === "flue") {
+            const r = await undeployCloudflare(name);
+            if (!r.removed)
+                throw new Error(`Cloudflare undeploy failed for "${name}". Check logs.`);
+            return { removed: true, logTail: r.logTail };
+        }
+        if (target === "claude-managed") {
+            const key = process.env.ANTHROPIC_API_KEY;
+            if (!key)
+                throw new Error("ANTHROPIC_API_KEY is not set — cannot undeploy from Claude Managed Agents.");
+            const rec = readDeployRecord(name, "claude-managed");
+            if (!rec)
+                throw new Error(`No claude-managed deploy record for workspace "${name}".`);
+            await undeployManagedAgent(rec, anthropicPublishClient(key));
+            clearDeployRecord(name, "claude-managed");
+            return { removed: true };
+        }
+        // agentcore
+        const rec = readDeployRecord(name, "agentcore");
+        if (!rec)
+            throw new Error(`No agentcore deploy record for workspace "${name}".`);
+        await undeployAgentcoreHarness(rec, realAgentcoreControlClient());
+        clearDeployRecord(name, "agentcore");
+        return { removed: true };
+    }
+    async deployRecord(input) {
+        const rec = readDeployRecord(input.query.name, input.query.backend);
+        return { record: rec };
+    }
+    async testbedDetect(input) {
+        return { flavor: detectFlavor(resolveProject(input.query.root)) };
+    }
+    async testbedSuggestion(input) {
+        const cwd = resolveProject(input.query.cwd ?? process.cwd());
+        const { looksLikeProject, flavor } = suggestTestbed(cwd);
+        return { cwd, looksLikeProject, flavor, name: basename(cwd) };
+    }
+    async testbedRecents(_input) {
+        const recents = readRecents(agentgemHome()).map((r) => ({ ...r, exists: existsSync(r.path) }));
+        return { recents };
+    }
+    // Cross-repo discovery from Claude/Codex session history. Ungated — the front door
+    // shows these under a "Discovered" section beneath the user's own recents.
+    async testbedProjects(input) {
+        return { projects: discoverProjects(resolveDirs(input.query.dir)) };
+    }
+    async scaffoldTestbed(input) {
+        const root = resolveProject(input.body.root);
+        const flavor = (input.body.flavor ?? "claude");
+        const res = scaffoldTestbed(root, input.body.name, flavor);
+        upsertRecent(agentgemHome(), { path: root, flavor, name: input.body.name });
+        return res;
+    }
+    async importTestbed(input) {
+        const rawInv = introspectConfig({ ...resolveDirs(input.body.dir), redact: false });
+        return importArtifacts(resolveProject(input.body.root), input.body.selection, rawInv, (input.body.flavor ?? "claude"));
+    }
+    // Resolve the configured registry source, or throw a clear error the UI can surface.
+    registrySource() {
+        const cfg = registryConfigFromEnv();
+        if (!cfg)
+            throw new Error("the registry is not configured — set AGENTGEM_REGISTRY_REPO");
+        return { cfg, source: githubRegistrySource(cfg) };
+    }
+    async registryReady(_input) {
+        return { ready: registryReady() };
+    }
+    async registryIndex(_input) {
+        return this.registrySource().source.getIndex();
+    }
+    async registryResolve(input) {
+        const { source } = this.registrySource();
+        const { plan } = await resolveInstall({ refs: input.body.refs, mode: input.body.mode, target: input.body.target, source });
+        return { plan };
+    }
+    // Apply: materialize into `dest`, or land the merged Gem in the workspace store.
+    async registryInstall(input) {
+        const { source } = this.registrySource();
+        const { plan, gem } = await resolveInstall({ refs: input.body.refs, mode: input.body.mode, target: input.body.target, source });
+        if (input.body.mode === "materialize") {
+            if (!input.body.dest)
+                throw new Error("materialize mode requires `dest`");
+            writeArchiveDir(input.body.dest, plan.materialize.files);
+            return { plan, applied: { mode: "materialize", dest: input.body.dest, written: Object.keys(plan.materialize.files) } };
+        }
+        const name = input.body.workspaceName ?? gem.name;
+        createWorkspace(name, gem);
+        return { plan, applied: { mode: "workspace", workspace: name } };
+    }
+    // OUTWARD-FACING: gated network publish. Reads a Gem from the workspace, writes its archive +
+    // updated index in one commit. Requires GITHUB_TOKEN (enforced by the publisher).
+    async registryPublish(input) {
+        const { cfg, source } = this.registrySource();
+        const gem = readGemArchive(readWorkspace(input.body.workspace).files); // WorkspaceDetail exposes .files, not .gem
+        const index = await source.getIndex();
+        return publishGem({
+            gem, scope: input.body.scope, name: input.body.name, version: input.body.version,
+            dependencies: input.body.dependencies, index, publisher: githubRegistryPublisher(cfg),
+        });
+    }
+    // Pop the OS-native folder picker and return the chosen absolute path (null if cancelled).
+    async pickFolder(_input) {
+        return { path: await pickFolder() };
+    }
+};
+__decorate([
+    get("/inventory", { query: DirQuerySchema, response: InventorySchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "inventory", null);
+__decorate([
+    post("/gem", { body: GemRequestSchema, response: GemSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "gem", null);
+__decorate([
+    post("/scaffold-checks", { body: ScaffoldChecksRequestSchema, response: ScaffoldChecksResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "scaffoldChecks", null);
+__decorate([
+    post("/materialize", { body: MaterializeRequestSchema, response: MaterializeResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "materialize", null);
+__decorate([
+    post("/archive", { body: ArchiveRequestSchema, response: ArchiveResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "archive", null);
+__decorate([
+    post("/workspaces", { body: CreateWorkspaceRequestSchema, response: WorkspaceSummarySchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "createWorkspace", null);
+__decorate([
+    get("/workspaces", { query: PickQuerySchema, response: ListWorkspacesResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "listWorkspaces", null);
+__decorate([
+    get("/workspace", { query: WorkspaceQuerySchema, response: WorkspaceDetailSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "readWorkspace", null);
+__decorate([
+    post("/workspace/render", { body: RenderRequestSchema, response: RenderResultSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "renderWorkspace", null);
+__decorate([
+    post("/workspace/delete", { body: WorkspaceNameRequestSchema, response: DeleteWorkspaceResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "deleteWorkspace", null);
+__decorate([
+    get("/run-ready", { query: RunReadyQuerySchema, response: RunReadyResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "runReady", null);
+__decorate([
+    post("/credential", { body: CredentialRequestSchema, response: CredentialResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "credential", null);
+__decorate([
+    post("/run", { body: RunRequestSchema, response: RunStateSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "run", null);
+__decorate([
+    get("/run-status", { query: RunStatusQuerySchema, response: RunStateSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "runStatus", null);
+__decorate([
+    post("/run/stop", { body: RunStopRequestSchema, response: RunStopResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "runStop", null);
+__decorate([
+    get("/agentcore/deploy-ready", { query: PickQuerySchema, response: AgentcoreReadyResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "agentcoreDeployReady", null);
+__decorate([
+    post("/agentcore/deploy", { body: AgentcoreDeployRequestSchema, response: AgentcoreDeployStateSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "agentcoreDeploy", null);
+__decorate([
+    get("/agentcore/deploy-status", { query: AgentcoreStatusQuerySchema, response: AgentcoreDeployStateSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "agentcoreDeployStatus", null);
+__decorate([
+    get("/deploy-targets", { query: PickQuerySchema, response: DeployTargetsResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "deployTargets", null);
+__decorate([
+    post("/publish-preview", { body: PublishPreviewRequestSchema, response: PublishPreviewResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "publishPreview", null);
+__decorate([
+    get("/publish-ready", { query: DeployReadyQuerySchema, response: PublishReadyResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "publishReady", null);
+__decorate([
+    post("/publish", { body: PublishRequestSchema, response: PublishResultSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "publish", null);
+__decorate([
+    post("/undeploy", { body: UndeployRequestSchema, response: UndeployResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "undeploy", null);
+__decorate([
+    get("/deploy-record", { query: DeployRecordQuerySchema, response: DeployRecordResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "deployRecord", null);
+__decorate([
+    get("/testbed/detect", { query: TestbedDetectQuerySchema, response: TestbedDetectResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "testbedDetect", null);
+__decorate([
+    get("/testbed/suggestion", { query: TestbedSuggestionQuerySchema, response: TestbedSuggestionResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "testbedSuggestion", null);
+__decorate([
+    get("/testbed/recents", { query: PickQuerySchema, response: TestbedRecentsResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "testbedRecents", null);
+__decorate([
+    get("/testbed/projects", { query: TestbedProjectsQuerySchema, response: TestbedProjectsResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "testbedProjects", null);
+__decorate([
+    post("/testbed/scaffold", { body: TestbedScaffoldRequestSchema, response: TestbedScaffoldResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "scaffoldTestbed", null);
+__decorate([
+    post("/testbed/import", { body: TestbedImportRequestSchema, response: TestbedImportResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "importTestbed", null);
+__decorate([
+    get("/registry/ready", { query: PickQuerySchema, response: RegistryReadyResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "registryReady", null);
+__decorate([
+    get("/registry/index", { query: PickQuerySchema, response: RegistryIndexResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "registryIndex", null);
+__decorate([
+    post("/registry/resolve", { body: RegistryResolveRequestSchema, response: RegistryResolveResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "registryResolve", null);
+__decorate([
+    post("/registry/install", { body: RegistryInstallRequestSchema, response: RegistryInstallResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "registryInstall", null);
+__decorate([
+    post("/registry/publish", { body: RegistryPublishRequestSchema, response: RegistryPublishResponseSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "registryPublish", null);
+__decorate([
+    get("/pick-folder", { query: PickQuerySchema, response: PickFolderSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemController.prototype, "pickFolder", null);
+GemController = __decorate([
+    api({ basePath: "/api" })
+], GemController);
+export { GemController };
+// Query params can't carry arrays cleanly, so `projects` arrives JSON-encoded.
+function parseProjectsQuery(s) {
+    if (!s)
+        return [];
+    try {
+        const v = JSON.parse(s);
+        return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+// Compose the global inventory with project sections. Each root is the user's explicit
+// native-picker selection; we canonicalize to absolute paths and dedup.
+function introspectAll(dir, projects) {
+    const inventory = introspectConfig(resolveDirs(dir));
+    const roots = (projects ?? []).map(resolveProject).filter((r, i, a) => r.length > 0 && a.indexOf(r) === i);
+    if (roots.length)
+        inventory.projects = roots.map(introspectProject);
+    return inventory;
+}

package/dist/gem.tools.js

@@ -0,0 +1,103 @@
+import { __decorate, __metadata } from "tslib";
+// src/gem.tools.ts
+import { z } from "zod";
+import { mcpServer, tool } from "@agentback/mcp";
+import { introspectConfig, introspectProject } from "./gem/introspect.js";
+import { buildGem } from "./gem/buildGem.js";
+import { GemSelectionSchema } from "./schemas.js";
+import { resolveDirs, resolveProject } from "./resolveDir.js";
+import { resolveInstall, publishGem } from "./gem/registry.js";
+import { githubRegistrySource, githubRegistryPublisher, registryConfigFromEnv } from "./gem/registryGithub.js";
+import { readWorkspace } from "./gem/workspaces.js";
+import { readGemArchive } from "./gem/archive.js";
+const InventoryInput = z.object({ dir: z.string().optional(), projects: z.array(z.string()).optional() });
+const GemInput = z.object({ selection: GemSelectionSchema, name: z.string().optional(), dir: z.string().optional(), projects: z.array(z.string()).optional() });
+const RegistryRefsInput = z.object({ refs: z.array(z.string()).min(1), mode: z.enum(["materialize", "workspace"]), target: z.string().optional() });
+const RegistryPublishInput = z.object({ workspace: z.string(), scope: z.string(), name: z.string().optional(), version: z.string(), dependencies: z.array(z.string()).optional() });
+function registrySourceOrThrow() {
+    const cfg = registryConfigFromEnv();
+    if (!cfg)
+        throw new Error("the registry is not configured — set AGENTGEM_REGISTRY_REPO");
+    return { cfg, source: githubRegistrySource(cfg) };
+}
+function introspectAll(dir, projects) {
+    const inventory = introspectConfig(resolveDirs(dir));
+    const roots = (projects ?? []).map(resolveProject).filter((r, i, a) => r.length > 0 && a.indexOf(r) === i);
+    if (roots.length)
+        inventory.projects = roots.map(introspectProject);
+    return inventory;
+}
+let GemTools = class GemTools {
+    async inventory(input) {
+        return introspectAll(input.dir, input.projects);
+    }
+    async gem(input) {
+        const dirs = resolveDirs(input.dir);
+        return buildGem(introspectAll(input.dir, input.projects), input.selection, { name: input.name ?? "gem", createdFrom: dirs.claudeDir });
+    }
+    async registryIndex(_input) {
+        return registrySourceOrThrow().source.getIndex();
+    }
+    async registryResolve(input) {
+        const { source } = registrySourceOrThrow();
+        const { plan } = await resolveInstall({ refs: input.refs, mode: input.mode, target: input.target, source });
+        return plan;
+    }
+    async registryInstall(input) {
+        const { source } = registrySourceOrThrow();
+        const { plan, gem } = await resolveInstall({ refs: input.refs, mode: input.mode, target: input.target, source });
+        return { plan, gem };
+    }
+    async registryPublish(input) {
+        const { cfg, source } = registrySourceOrThrow();
+        const gem = readGemArchive(readWorkspace(input.workspace).files);
+        const index = await source.getIndex();
+        return publishGem({ gem, scope: input.scope, name: input.name, version: input.version, dependencies: input.dependencies, index, publisher: githubRegistryPublisher(cfg) });
+    }
+};
+__decorate([
+    tool("inventory", {
+        description: "Introspect the local coding-agent config (skills, MCP servers, CLAUDE.md). Pass project roots to also include project-level artifacts. Secrets are redacted.",
+        input: InventoryInput,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemTools.prototype, "inventory", null);
+__decorate([
+    tool("build_gem", {
+        description: "Build a redacted Gem from a selection of the introspected config artifacts.",
+        input: GemInput,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemTools.prototype, "gem", null);
+__decorate([
+    tool("registry_index", { description: "List the gems available in the configured registry (names, versions, dependencies).", input: z.object({}) }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemTools.prototype, "registryIndex", null);
+__decorate([
+    tool("registry_resolve", { description: "Resolve registry refs into an install plan (items, artifacts, required secrets, and a materialize preview for a target). No writes.", input: RegistryRefsInput }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemTools.prototype, "registryResolve", null);
+__decorate([
+    tool("registry_install", { description: "Resolve + merge registry refs, returning the merged Gem and install plan. (Disk/workspace placement is performed via the REST /registry/install endpoint.)", input: RegistryRefsInput }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemTools.prototype, "registryInstall", null);
+__decorate([
+    tool("registry_publish", { description: "Publish a workspace Gem to the registry as @scope/name@version (requires GITHUB_TOKEN).", input: RegistryPublishInput }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GemTools.prototype, "registryPublish", null);
+GemTools = __decorate([
+    mcpServer()
+], GemTools);
+export { GemTools };