@ninemind/agentgem 0.1.0

package/dist/gem/testbed.js

@@ -0,0 +1,103 @@
+// src/gem/testbed.ts
+// The inverse of introspect.ts: scaffold a runnable .claude/ testbed and merge selected
+// GLOBAL artifacts into it. MCP/hook secrets are copied verbatim from raw global config into
+// the LOCAL testbed only (never into a Gem). Owns its own read-merge-write disk I/O.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { TESTBED_FLAVORS } from "./testbedFlavors.js";
+function readJson(abs) {
+    try {
+        const v = JSON.parse(readFileSync(abs, "utf8"));
+        return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeJson(abs, obj) {
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, JSON.stringify(obj, null, 2) + "\n", "utf8");
+}
+export function scaffoldTestbed(root, name, flavor = "claude") {
+    const { created } = TESTBED_FLAVORS[flavor].scaffold(root, name);
+    return { root, created };
+}
+function marker(name) {
+    return { open: `<!-- agentgem:imported ${name} -->`, close: `<!-- /agentgem:end ${name} -->` };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// Replace an existing marked block, else append one. Keeps re-import idempotent.
+// Returns true when an existing block was replaced (so the caller can report `overwritten`).
+function upsertMarkedBlock(root, rel, name, content) {
+    const abs = join(root, rel);
+    const existing = existsSync(abs) ? readFileSync(abs, "utf8") : "";
+    const { open, close } = marker(name);
+    const block = `${open}\n${content}\n${close}`;
+    const re = new RegExp(`${escapeRegex(open)}[\\s\\S]*?${escapeRegex(close)}`);
+    const replaced = re.test(existing);
+    const next = replaced ? existing.replace(re, block) : `${existing}${existing && !existing.endsWith("\n") ? "\n" : ""}${block}\n`;
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, next, "utf8");
+    return replaced;
+}
+export function importArtifacts(root, selection, rawInv, flavor = "claude") {
+    const written = [];
+    const skipped = [];
+    const { import: imp, label } = TESTBED_FLAVORS[flavor];
+    for (const name of selection.skills ?? []) {
+        const sk = rawInv.skills.find((s) => s.name === name);
+        if (!sk) {
+            skipped.push({ artifact: name, reason: "not found in global inventory" });
+            continue;
+        }
+        const rel = imp.skillRel(name);
+        const overwritten = existsSync(join(root, rel));
+        mkdirSync(dirname(join(root, rel)), { recursive: true });
+        writeFileSync(join(root, rel), sk.content, "utf8");
+        written.push({ type: "skill", name, overwritten });
+    }
+    if (selection.includeInstructions) {
+        for (const ins of rawInv.instructions) {
+            const overwritten = upsertMarkedBlock(root, imp.instructionsFile, ins.name, ins.content);
+            written.push({ type: "instructions", name: ins.name, overwritten });
+        }
+    }
+    for (const name of selection.mcpServers ?? []) {
+        const m = rawInv.mcpServers.find((s) => s.name === name);
+        if (!m) {
+            skipped.push({ artifact: name, reason: "not found in global inventory" });
+            continue;
+        }
+        if (!imp.writeMcp) {
+            skipped.push({ artifact: name, reason: `${label} has no MCP-server config` });
+            continue;
+        }
+        const overwritten = imp.writeMcp(root, name, m.config); // raw config — local testbed only
+        written.push({ type: "mcp_server", name, overwritten });
+    }
+    for (const name of selection.hooks ?? []) {
+        const h = rawInv.hooks.find((x) => x.name === name);
+        if (!h) {
+            skipped.push({ artifact: name, reason: "not found in global inventory" });
+            continue;
+        }
+        if (!imp.supportsHooks) {
+            skipped.push({ artifact: name, reason: `${label} has no hooks` });
+            continue;
+        }
+        const abs = join(root, ".claude", "settings.json");
+        const doc = readJson(abs);
+        const hooks = (doc.hooks && typeof doc.hooks === "object" ? doc.hooks : {});
+        const groups = Array.isArray(hooks[h.event]) ? hooks[h.event] : [];
+        const exists = groups.some((g) => JSON.stringify(g) === JSON.stringify(h.config));
+        if (!exists)
+            groups.push(h.config);
+        hooks[h.event] = groups;
+        doc.hooks = hooks;
+        writeJson(abs, doc);
+        written.push({ type: "hook", name, overwritten: false });
+    }
+    return { written, skipped };
+}

package/dist/gem/testbedFlavors.js

@@ -0,0 +1,287 @@
+// src/gem/testbedFlavors.ts
+// The set of harness "flavors" a testbed can be authored/test-driven as. Flavors drive the
+// flavor-specific bits — detection, scaffold skeleton, test-drive run command, and import support.
+// Introspection is flavor-agnostic (introspectProject reads whatever project config is present).
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseTomlMcpServers, tomlMcpServers } from "./toml.js";
+function writeIfAbsent(root, rel, content, created) {
+    const abs = join(root, rel);
+    if (existsSync(abs))
+        return;
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, content, "utf8");
+    created.push(rel);
+}
+// Remove every [mcp_servers...] section (header through to the next top-level table or EOF),
+// preserving all other content. Lets writeMcpCodexToml regenerate just the MCP block.
+function stripMcpServerBlocks(toml) {
+    const out = [];
+    let skipping = false;
+    for (const line of toml.split("\n")) {
+        if (/^\s*\[/.test(line))
+            skipping = /^\s*\[mcp_servers(\.|\])/.test(line); // a table header (re)sets the mode
+        if (!skipping)
+            out.push(line);
+    }
+    return out.join("\n");
+}
+export function writeMcpCodexToml(root, name, rawConfig) {
+    const abs = join(root, ".codex", "config.toml");
+    const text = existsSync(abs) ? readFileSync(abs, "utf8") : "";
+    const servers = parseTomlMcpServers(text);
+    const overwritten = name in servers;
+    servers[name] = rawConfig; // raw config — local testbed only
+    const nonMcp = stripMcpServerBlocks(text).trimEnd();
+    const arts = Object.entries(servers).map(([n, config]) => ({ type: "mcp_server", name: n, transport: "stdio", config }));
+    const block = tomlMcpServers(arts); // regenerated [mcp_servers...] section
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, (nonMcp ? nonMcp + "\n\n" : "") + block, "utf8");
+    return overwritten;
+}
+function readJsonFile(abs) {
+    try {
+        const v = JSON.parse(readFileSync(abs, "utf8"));
+        return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function writeMcpJson(root, name, rawConfig) {
+    const abs = join(root, ".mcp.json");
+    const doc = readJsonFile(abs);
+    const servers = (doc.mcpServers && typeof doc.mcpServers === "object" ? doc.mcpServers : {});
+    const overwritten = name in servers;
+    servers[name] = rawConfig; // raw config — local testbed only
+    doc.mcpServers = servers;
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, JSON.stringify(doc, null, 2) + "\n", "utf8");
+    return overwritten;
+}
+export const TESTBED_FLAVORS = {
+    claude: {
+        id: "claude", label: "Claude Code", runCommand: "claude", importSupported: true,
+        detect: (root) => existsSync(join(root, ".claude")) || existsSync(join(root, "CLAUDE.md")),
+        // ~/.claude/projects/<path-encoded>/<uuid>.jsonl — folder name is lossy, so read
+        // the real cwd out of the newest session in each folder.
+        discoverProjects: (dirs) => discoverClaudeProjects(dirs.claudeDir),
+        scaffold: (root, name) => {
+            const created = [];
+            mkdirSync(join(root, ".claude", "skills"), { recursive: true });
+            writeIfAbsent(root, ".claude/settings.json", "{}\n", created);
+            writeIfAbsent(root, "CLAUDE.md", `# ${name}\n`, created);
+            writeIfAbsent(root, ".gitignore", ".mcp.json\n.claude/settings.json\n.env\n.targets/\n", created);
+            return { created };
+        },
+        import: { skillRel: (n) => `.claude/skills/${n}/SKILL.md`, instructionsFile: "CLAUDE.md", writeMcp: writeMcpJson, supportsHooks: true },
+    },
+    codex: {
+        id: "codex", label: "Codex", runCommand: "codex", importSupported: true,
+        detect: (root) => existsSync(join(root, ".codex")) || existsSync(join(root, "AGENTS.md")),
+        // ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl — date-partitioned, so walk the
+        // tree and pull payload.cwd from each session_meta header line.
+        discoverProjects: (dirs) => discoverCodexProjects(dirs.codexDir),
+        scaffold: (root, name) => {
+            const created = [];
+            mkdirSync(join(root, ".agents", "skills"), { recursive: true });
+            writeIfAbsent(root, "AGENTS.md", `# ${name}\n`, created);
+            writeIfAbsent(root, ".gitignore", ".codex/config.toml\n.env\n.targets/\n", created);
+            return { created };
+        },
+        import: { skillRel: (n) => `.agents/skills/${n}/SKILL.md`, instructionsFile: "AGENTS.md", writeMcp: writeMcpCodexToml, supportsHooks: false },
+    },
+    hermes: {
+        id: "hermes", label: "Hermes", runCommand: "hermes", importSupported: true,
+        detect: (root) => existsSync(join(root, ".hermes")),
+        // Hermes sessions are Slack/agent threads (~/.hermes/sessions/sessions.json),
+        // not filesystem repos — there is no project cwd to harvest.
+        discoverProjects: () => [],
+        scaffold: (root, name) => {
+            const created = [];
+            mkdirSync(join(root, ".hermes", "skills"), { recursive: true });
+            writeIfAbsent(root, ".hermes/SOUL.md", `# ${name}\n`, created);
+            writeIfAbsent(root, ".gitignore", ".hermes/config.yaml\n.env\n.targets/\n", created);
+            return { created };
+        },
+        import: { skillRel: (n) => `.hermes/skills/${n}/DESCRIPTION.md`, instructionsFile: ".hermes/SOUL.md", writeMcp: undefined, supportsHooks: false },
+    },
+};
+export function flavorIds() {
+    return Object.keys(TESTBED_FLAVORS);
+}
+// Single marker match -> that flavor; none or several -> null (caller asks).
+export function detectFlavor(root) {
+    const hits = flavorIds().filter((id) => TESTBED_FLAVORS[id].detect(root));
+    return hits.length === 1 ? hits[0] : null;
+}
+export function suggestTestbed(root) {
+    const anyMarker = flavorIds().some((id) => TESTBED_FLAVORS[id].detect(root));
+    const looksLikeProject = anyMarker || existsSync(join(root, ".git"));
+    return { looksLikeProject, flavor: detectFlavor(root) };
+}
+// Union of every flavor's discovered projects: dedup per (flavor, path) keeping
+// the most recent hit, validate the path still exists, sort newest-first.
+export function discoverProjects(dirs) {
+    const best = new Map();
+    for (const id of flavorIds()) {
+        for (const proj of TESTBED_FLAVORS[id].discoverProjects(dirs)) {
+            const key = `${id} ${proj.path}`;
+            const prev = best.get(key);
+            if (!prev || proj.lastUsedMs > prev.lastUsedMs)
+                best.set(key, { ...proj, flavor: id });
+        }
+    }
+    return [...best.values()]
+        .sort((a, b) => b.lastUsedMs - a.lastUsedMs)
+        .map((p) => ({
+        path: p.path,
+        flavor: p.flavor,
+        lastUsed: new Date(p.lastUsedMs).toISOString(),
+        exists: existsSync(p.path),
+    }));
+}
+// Read up to maxBytes from the front of a file. Session .jsonl files can be many
+// MB; cwd lives near the top, so a bounded read avoids slurping whole transcripts.
+function readHead(file, maxBytes = 1 << 16) {
+    let fd;
+    try {
+        fd = openSync(file, "r");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const n = readSync(fd, buf, 0, maxBytes, 0);
+        return buf.toString("utf8", 0, n);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function firstLine(text) {
+    const nl = text.indexOf("\n");
+    return nl === -1 ? text : text.slice(0, nl);
+}
+function safeMtime(p) {
+    try {
+        return statSync(p).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+const CWD_RE = /"cwd":"((?:[^"\\]|\\.)*)"/;
+// A session file's cwd never changes, so memoize the expensive head-read+parse by
+// path. Recency (statSync) stays live and uncached. Bounded by sessions on disk.
+const cwdByFile = new Map();
+function cachedCwd(file, extract) {
+    const hit = cwdByFile.get(file);
+    if (hit !== undefined)
+        return hit;
+    const cwd = extract(file);
+    cwdByFile.set(file, cwd);
+    return cwd;
+}
+function readClaudeCwd(file) {
+    const head = readHead(file);
+    const match = head ? CWD_RE.exec(head) : null;
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(`"${match[1]}"`); // unescape \\ and friends
+    }
+    catch {
+        return match[1];
+    }
+}
+// Claude writes one folder per project under ~/.claude/projects, each holding
+// <uuid>.jsonl sessions. We take the newest session per folder and regex its cwd
+// (the first session line is sometimes a summary record with no cwd).
+function discoverClaudeProjects(claudeDir) {
+    const projectsDir = join(claudeDir, "projects");
+    let entries;
+    try {
+        entries = readdirSync(projectsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const session = newestJsonl(join(projectsDir, entry.name));
+        if (!session)
+            continue;
+        const cwd = cachedCwd(session, readClaudeCwd);
+        if (cwd)
+            out.push({ path: cwd, lastUsedMs: safeMtime(session) });
+    }
+    return out;
+}
+function newestJsonl(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    let newest = null;
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+            continue;
+        const file = join(dir, entry.name);
+        const mtimeMs = safeMtime(file);
+        if (!newest || mtimeMs > newest.mtimeMs)
+            newest = { file, mtimeMs };
+    }
+    return newest?.file ?? null;
+}
+function readCodexMetaCwd(file) {
+    const head = readHead(file);
+    if (!head)
+        return null;
+    try {
+        const rec = JSON.parse(firstLine(head));
+        const cwd = rec?.payload?.cwd;
+        return typeof cwd === "string" ? cwd : null;
+    }
+    catch {
+        return null; // malformed header
+    }
+}
+// Codex partitions sessions by date, so we walk the whole tree. Each rollout file
+// opens with a {"type":"session_meta","payload":{"cwd":...}} header line.
+function discoverCodexProjects(codexDir) {
+    const files = [];
+    walkJsonl(join(codexDir, "sessions"), files);
+    const out = [];
+    for (const file of files) {
+        const cwd = cachedCwd(file, readCodexMetaCwd);
+        if (cwd)
+            out.push({ path: cwd, lastUsedMs: safeMtime(file) });
+    }
+    return out;
+}
+function walkJsonl(dir, out) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const p = join(dir, entry.name);
+        if (entry.isDirectory())
+            walkJsonl(p, out);
+        else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            out.push(p);
+    }
+}

package/dist/gem/toml.js

@@ -0,0 +1,120 @@
+const BARE = /^[A-Za-z0-9_-]+$/;
+function escapeStr(s) {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+}
+function key(k) {
+    return BARE.test(k) ? k : `"${escapeStr(k)}"`;
+}
+function scalar(v) {
+    if (typeof v === "string")
+        return `"${escapeStr(v)}"`;
+    if (typeof v === "number" || typeof v === "boolean")
+        return String(v);
+    return `"${escapeStr(String(v))}"`;
+}
+function isScalar(v) {
+    return v === null || typeof v !== "object";
+}
+export function tomlMcpServers(servers) {
+    const blocks = [];
+    for (const s of servers) {
+        const lines = [`[mcp_servers.${key(s.name)}]`];
+        const subTables = [];
+        for (const [k, v] of Object.entries(s.config)) {
+            if (isScalar(v))
+                lines.push(`${key(k)} = ${scalar(v)}`);
+            else if (Array.isArray(v))
+                lines.push(`${key(k)} = [${v.map(scalar).join(", ")}]`);
+            else if (v && typeof v === "object") {
+                const sub = [`[mcp_servers.${key(s.name)}.${key(k)}]`];
+                for (const [k2, v2] of Object.entries(v))
+                    sub.push(`${key(k2)} = ${scalar(v2)}`);
+                subTables.push(sub.join("\n"));
+            }
+        }
+        blocks.push([lines.join("\n"), ...subTables].join("\n\n"));
+    }
+    return blocks.length ? blocks.join("\n\n") + "\n" : "";
+}
+// Inverse of tomlMcpServers for the [mcp_servers.*] subset only (scalars, scalar arrays, one level of
+// sub-tables). Not a general TOML parser. Unknown/other top-level tables are ignored.
+function parseScalar(raw) {
+    const s = raw.trim();
+    if (s.startsWith('"') && s.endsWith('"')) {
+        return s.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    if (s === "true")
+        return true;
+    if (s === "false")
+        return false;
+    if (/^-?\d+(\.\d+)?$/.test(s))
+        return Number(s);
+    return s;
+}
+function parseArray(raw) {
+    const inner = raw.trim().replace(/^\[/, "").replace(/\]$/, "").trim();
+    if (!inner)
+        return [];
+    // split on commas not inside quotes
+    const parts = [];
+    let cur = "";
+    let inStr = false;
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '"' && inner[i - 1] !== "\\")
+            inStr = !inStr;
+        if (ch === "," && !inStr) {
+            parts.push(cur);
+            cur = "";
+        }
+        else
+            cur += ch;
+    }
+    if (cur.trim())
+        parts.push(cur);
+    return parts.map((p) => parseScalar(p));
+}
+function unquoteKey(k) {
+    const s = k.trim();
+    return s.startsWith('"') && s.endsWith('"') ? s.slice(1, -1) : s;
+}
+export function parseTomlMcpServers(toml) {
+    const out = {};
+    let server = null;
+    let sub = null; // sub-table key (e.g. "env") within the current server
+    for (const rawLine of toml.split("\n")) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const header = line.match(/^\[mcp_servers\.([^\]]+)\]$/);
+        if (header) {
+            // split "name" or "name.sub" on the first dot outside quotes
+            const segs = header[1].match(/("(?:[^"\\]|\\.)*"|[^.]+)/g) ?? [];
+            const name = unquoteKey(segs[0] ?? "");
+            server = name;
+            sub = segs[1] ? unquoteKey(segs[1]) : null;
+            out[server] ??= {};
+            if (sub)
+                (out[server][sub] ??= {});
+            continue;
+        }
+        if (line.startsWith("[")) {
+            server = null;
+            sub = null;
+            continue;
+        } // some other table
+        if (!server)
+            continue;
+        const eq = line.indexOf("=");
+        if (eq < 0)
+            continue;
+        const key = unquoteKey(line.slice(0, eq));
+        const valRaw = line.slice(eq + 1).trim();
+        const val = valRaw.startsWith("[") ? parseArray(valRaw) : parseScalar(valRaw);
+        if (sub)
+            out[server][sub][key] = val;
+        else
+            out[server][key] = val;
+    }
+    return out;
+}

package/dist/gem/types.js

@@ -0,0 +1 @@
+export {};

package/dist/gem/workspaces.js

@@ -0,0 +1,93 @@
+// src/gem/workspaces.ts
+// A gem's persistent local home: the canonical archive at the workspace root (source of truth) plus
+// .targets/<target>/ rendered harness layouts (derived). Orchestration over the pure archive/materialize
+// core; this module owns all workspace filesystem I/O.
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, rmSync, readdirSync, statSync, existsSync, readFileSync } from "node:fs";
+import { materialize, compatibility, TARGET_REGISTRY, safePathSegment } from "./targets.js";
+import { writeGemArchive, readGemArchive } from "./archive.js";
+import { writeArchiveDir, readArchiveDir } from "./archiveFs.js";
+const TARGETS_DIR = ".targets";
+export function workspacesRoot() {
+    const home = process.env.AGENTGEM_HOME ?? join(homedir(), ".agentgem");
+    return join(home, "workspaces");
+}
+// A workspace name must already be a safe single path segment — reject anything else (no separators,
+// no `.`/`..`), so two distinct requests never collide to one directory and nothing escapes the root.
+export function workspaceName(name) {
+    const seg = safePathSegment(name);
+    if (seg !== name)
+        throw new Error(`invalid workspace name '${name}' — use only [A-Za-z0-9._-], no separators`);
+    return seg;
+}
+export function workspaceDir(name) {
+    return join(workspacesRoot(), workspaceName(name));
+}
+function countArtifacts(entries) {
+    const c = { skill: 0, mcp_server: 0, instructions: 0, hook: 0 };
+    for (const e of entries)
+        if (e.type in c)
+            c[e.type]++;
+    return c;
+}
+function renderedTargets(dir) {
+    const t = join(dir, TARGETS_DIR);
+    if (!existsSync(t))
+        return [];
+    return readdirSync(t).filter((n) => statSync(join(t, n)).isDirectory() && n in TARGET_REGISTRY);
+}
+function summary(name, manifestJson, dir) {
+    const m = JSON.parse(manifestJson);
+    return {
+        name,
+        gemName: m.name,
+        version: m.version,
+        artifactCounts: countArtifacts(m.artifacts),
+        checks: m.checks.length,
+        renderedTargets: renderedTargets(dir),
+    };
+}
+export function createWorkspace(name, gem, opts = {}) {
+    const dir = workspaceDir(name);
+    if (existsSync(dir))
+        throw new Error(`workspace '${name}' already exists`);
+    const { files } = writeGemArchive(gem, { version: opts.version });
+    mkdirSync(dir, { recursive: true });
+    writeArchiveDir(dir, files);
+    return summary(workspaceName(name), files["gem.json"], dir);
+}
+export function listWorkspaces() {
+    const root = workspacesRoot();
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root)
+        .filter((n) => statSync(join(root, n)).isDirectory() && existsSync(join(root, n, "gem.json")))
+        .map((n) => summary(n, readFileSync(join(root, n, "gem.json"), "utf8"), join(root, n)));
+}
+export function readWorkspace(name) {
+    const dir = workspaceDir(name);
+    if (!existsSync(join(dir, "gem.json")))
+        throw new Error(`no workspace '${name}'`);
+    const files = readArchiveDir(dir); // skips .targets/ (Task 2)
+    const gem = readGemArchive(files); // verifies the lock
+    return { ...summary(workspaceName(name), files["gem.json"], dir), files, compatibility: compatibility(gem) };
+}
+export function renderTarget(name, target) {
+    const dir = workspaceDir(name);
+    if (!existsSync(join(dir, "gem.json")))
+        throw new Error(`no workspace '${name}'`);
+    const gem = readGemArchive(readArchiveDir(dir));
+    const { files, skipped } = materialize(gem, target);
+    const out = join(dir, TARGETS_DIR, target);
+    rmSync(out, { recursive: true, force: true }); // clear stale renders
+    mkdirSync(out, { recursive: true });
+    writeArchiveDir(out, files);
+    return { target, files, skipped, path: out };
+}
+export function deleteWorkspace(name) {
+    const dir = workspaceDir(name);
+    if (!existsSync(dir))
+        throw new Error(`no workspace '${name}'`);
+    rmSync(dir, { recursive: true, force: true });
+}