@atolis-hq/corum 0.1.5 → 0.1.7

package/README.md

@@ -1,220 +1,220 @@
 # Corum
 
-Corum loads design graph files from disk into an in-memory graph and exposes the graph through MCP tools.
-
-## Requirements
-
-- Node.js 20 or newer
-- npm
+Corum is a Git-native design graph for service architecture. It models components (APIs, domain models, schemas, fields) as nodes with typed edges, and exposes the graph through MCP tools so AI assistants can reason about your architecture.
 
 ## Install
 
-From the repository root:
-
-```powershell
-npm install
+```bash
+npm install -g @atolis-hq/corum
 ```
 
-This installs TypeScript, the MCP SDK, and YAML parsing dependencies.
+Or run without installing:
 
-## Build
+```bash
+npx @atolis-hq/corum <command>
+```
 
-Compile the TypeScript sources into `dist/`:
+**Windows:** If you see an "execution policy" error in PowerShell, run this once:
 
 ```powershell
-npm run build
+Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
 ```
 
-The build command runs `tsc`.
+This is a standard one-time setup step for Node.js development on Windows. Alternatively, `npx @atolis-hq/corum <command>` works without any setup on all platforms.
 
-## Test
+## Update
 
-Run the full test suite:
+```bash
+npm update -g @atolis-hq/corum
+```
 
-```powershell
-npm test
+## Quick Start
+
+Scaffold a new project in the current directory:
+
+```bash
+corum init
 ```
 
-This compiles the project and runs the Node test runner against:
+This creates `.corum/config.yaml`, scaffolds a graph at `.corum/graph/`, and downloads the official template packs (`core`, `domain`, `rest`, `messaging`). Then start the MCP server:
 
-- `test/schema.test.ts`
-- `test/loader.test.ts`
-- `test/graph.test.ts`
-- `test/mcp.test.ts`
-- `test/writer.test.ts`
-- `test/serializer.test.ts`
+```bash
+corum mcp
+```
 
-The fixture graph used by the tests is in `fixtures/sample-graph`. The tests verify that it loads as `45` nodes and `38` edges.
+## Commands
 
-## Run The MCP Server
+### `corum mcp`
 
-Build first:
+Start the MCP stdio server. Also starts a web UI by default.
 
-```powershell
-npm run build
+```bash
+corum mcp [options]
+
+Options:
+  --no-web          Suppress the web UI
+  --watch           Reload graph on file changes
+  --graph <path>    Override the graph directory
 ```
 
-Run the MCP server against the default graph path:
+### `corum web`
 
-```powershell
-npm run mcp
-```
+Start the web UI only.
 
-By default, the server loads:
+```bash
+corum web [options]
 
-```text
-.corum/graph
+Options:
+  --port <n>        Port to listen on (default: 3000)
+  --graph <path>    Override the graph directory
 ```
 
-To run it against the sample graph fixture instead:
+### `corum init`
 
-```powershell
-$env:CORUM_GRAPH_PATH = "fixtures/sample-graph"
-npm run mcp
+Scaffold a `.corum/` project structure and install the four default template packs (`core`, `domain`, `rest`, `messaging`). Skips any step where the target already exists.
+
+```bash
+corum init
 ```
 
-To reload the in-memory graph when graph YAML or template YAML files change, pass `--watch` to the built server:
+Creates:
+- `.corum/config.yaml` - project configuration
+- `.corum/graph/graph.yaml` - graph definition
+- `.corum/graph/components/` and `.corum/graph/edges/` - empty directories ready for nodes
+- `.corum/packs/` - downloaded template packs
+- `.corum/packs.yaml` - local manifest of installed packs
 
-```powershell
-node dist/src/mcp/index.js --watch
-```
+### `corum pack install`
 
-The same watcher can be enabled for the web server with `node dist/src/web/server.js --watch`, or for either server by setting `CORUM_FILE_WATCHER=true`.
+Install a template pack from the registry into `.corum/packs/`. Appends the pack to `.corum/graph/graph.yaml` and records it in `.corum/packs.yaml`.
 
-Starting with powershell
+```bash
+corum pack install <name>          # install latest tag
+corum pack install <name>@<ref>    # install a specific tag
 ```
- $env:CORUM_GRAPH_PATH = "fixtures/sample-graph";
- $env:CORUM_WEB_PORT = 3001;
- $env:CORUM_FILE_WATCHER="true";
- npm run web
+
+Examples:
+
+```bash
+corum pack install domain
+corum pack install domain@v0.1.5
 ```
 
-To run the web app against a git repository instead of a filesystem graph path, set `CORUM_SOURCE=git` before starting the app.
+### `corum pack list`
 
-For a local git repository:
+List installed packs with their resolved version and install date.
 
-```powershell
-$env:CORUM_SOURCE = "git"
-$env:CORUM_GIT_LOCAL_PATH = "C:\git\atolis-hq\corum-design-graph"
-$env:CORUM_GIT_BRANCH = "main"
-$env:CORUM_GIT_POLL_SECONDS = 10
-$env:CORUM_WEB_PORT = 3001
-npm run web
+```bash
+corum pack list
 ```
 
-For a remote repository:
+### `corum import`
 
-```powershell
-$env:CORUM_SOURCE = "git"
-$env:CORUM_GIT_REMOTE_URL = "https://github.com/org/design-repo.git"
-$env:CORUM_GIT_BRANCH = "main"
-$env:CORUM_GIT_POLL_SECONDS = 10
-$env:CORUM_WEB_PORT = 3001
-npm run web
+Import specifications into the graph.
+
+```bash
+corum import --config <path>    Import using a config YAML file
 ```
 
-For private remote repositories, also set `CORUM_GIT_TOKEN`. `CORUM_GIT_USERNAME` defaults to `x-access-token` when a token is present.
+#### `corum import openapi <spec>`
+
+Import an OpenAPI spec directly.
 
-The same git source config is used by `npm run mcp`. Git-backed startup expects graph files in `.corum/graph` and template packs in `.corum/packs`, and loads the selected branch at process start.
+```bash
+corum import openapi <spec> [options]
 
-`CORUM_GIT_POLL_SECONDS` is optional. When set to a positive number of seconds, the web server polls the git source for branch/ref changes, invalidates its cached multi-branch view, and reloads the app automatically. If it is not set, git-backed content is not polled.
+Options:
+  --component-strategy <strategy>   Component mapping: uri-segment (default), tag, hardcoded
+  --segment <n>                     URI segment index (uri-segment strategy)
+  --pattern <regex>                 Regex pattern (uri-segment strategy)
+  --component <name>                Component name (hardcoded strategy)
+  --graph <path>                    Override the graph directory
+```
+
+## Configuration
 
-`CORUM_FILE_WATCHER` only watches filesystem graph paths. It does not watch git refs. For git-backed web sessions, you can either enable `CORUM_GIT_POLL_SECONDS` or use the always-visible `Reload` button in the branch bar to force a refresh.
+Run `corum init` to generate a `.corum/config.yaml` with all available options. Corum walks up from the current directory to find it, so you can place it at your project root.
 
-The MCP server exposes these tools:
+**Precedence (highest to lowest):** CLI flags → environment variables → `.corum/config.yaml`
 
-- `list_nodes`: lists graph nodes, optionally filtered by `template`, `component`, `state`, or `stability`
-- `list_templates`: lists loaded graph templates with summary metadata
-- `get_template`: returns full details for a loaded graph template
-- `get_cluster`: returns a root node, owned child nodes, and edges inside that cluster
-- `get_linked_fields`: returns `maps-to` edges touching fields owned by a root node
+| Config key | Environment variable | Description |
+|---|---|---|
+| `pack_registry` | - | URL of the pack registry YAML (set by `corum init`) |
+| `source` | `CORUM_SOURCE` | `file` (default) or `git` |
+| `graph` | `CORUM_GRAPH_PATH` | Path to the graph directory |
+| `git_local_path` | `CORUM_GIT_LOCAL_PATH` | Local git repo path |
+| `git_remote_url` | `CORUM_GIT_REMOTE_URL` | Remote git repo URL |
+| `git_branch` | `CORUM_GIT_BRANCH` | Branch to load |
+| `git_poll_seconds` | `CORUM_GIT_POLL_SECONDS` | Polling interval for remote git |
+| `git_token` | `CORUM_GIT_TOKEN` | Auth token for private repos |
+| `git_username` | `CORUM_GIT_USERNAME` | Auth username (default: `x-access-token`) |
 
-Each tool accepts an optional `format` argument:
+### File source (default)
 
-- `yaml`: default, human-readable YAML
-- `json`: pretty JSON
-- `toon`: TOON output via the official `@toon-format/toon` encoder for lower token use
+```yaml
+# .corum/config.yaml
+source: file
+graph: .corum/graph
+```
 
-Each tool also accepts `compact_keys: true` to shorten common graph keys before serialization. This works with all formats:
+### Git source
 
-```text
-id -> i
-template -> t
-component -> cp
-state -> s
-stability -> st
-schemaVersion -> sv
-lastModifiedAt -> lm
-extractedFrom -> xf
-properties -> p
-root -> r
-children -> ch
-edges -> e
-nodes -> n
-from -> fr
-to -> to
-type -> ty
-notes -> nt
+```yaml
+# .corum/config.yaml
+source: git
+git_remote_url: https://github.com/org/design-repo
+git_branch: main
+git_poll_seconds: 30
 ```
 
+For private repositories, set `CORUM_GIT_TOKEN` as an environment variable rather than storing it in the config file.
+
 ## MCP Client Configuration
 
-This repo includes a project-level `.mcp.json`:
+Configure your MCP client to run Corum. For Claude Code or Claude Desktop:
 
 ```json
 {
   "mcpServers": {
     "corum": {
-      "command": "node",
-      "args": ["dist/src/mcp/index.js"],
+      "command": "npx",
+      "args": ["@atolis-hq/corum", "mcp", "--no-web"],
       "env": {
-        "CORUM_GRAPH_PATH": "fixtures/sample-graph"
+        "CORUM_GRAPH_PATH": "/path/to/your/graph"
       }
     }
   }
 }
 ```
 
-Build the project before using this config from an MCP client:
-
-```powershell
-npm run build
-```
-
-The checked-in config points at `fixtures/sample-graph` so the tools return sample nodes immediately. Change `CORUM_GRAPH_PATH` to `.corum/graph` when you have graph component files there.
-
-## MCP Smoke Test
-
-Run a local MCP client against the configured server and print graph data:
+Or if installed globally:
 
-```powershell
-npm run mcp:smoke
+```json
+{
+  "mcpServers": {
+    "corum": {
+      "command": "corum",
+      "args": ["mcp", "--no-web"],
+      "env": {
+        "CORUM_GRAPH_PATH": "/path/to/your/graph"
+      }
+    }
+  }
+}
 ```
 
-The smoke test starts the MCP server over stdio and calls:
-
-- `list_nodes`
-- `list_nodes` filtered to `APIEndpoint`
-- `get_cluster` for `orders.DomainModel.order`
-- `get_linked_fields` for `orders.DomainModel.order`
+## MCP Tools
 
-## Useful Development Commands
+| Tool | Description |
+|---|---|
+| `list_nodes` | List graph nodes, optionally filtered by `template`, `component`, `state`, or `stability` |
+| `list_templates` | List loaded templates with summary metadata |
+| `get_template` | Return full details for a template |
+| `get_cluster` | Return a root node, its owned children, and internal edges |
+| `get_linked_fields` | Return `maps-to` edges touching fields owned by a root node |
 
-Type-check without emitting files:
-
-```powershell
-npx tsc --noEmit
-```
+All tools accept an optional `format` argument: `yaml` (default), `json`, or `toon`. All tools also accept `compact_keys: true` to shorten common keys before serialization, reducing token usage.
 
-Run one compiled test file after building:
+## Contributing
 
-```powershell
-npm run build
-node --test dist/test/loader.test.js
-```
-
-Clean generated build output manually if needed:
-
-```powershell
-Remove-Item -Recurse -Force dist
-```
+See [DEVELOPMENT.md](DEVELOPMENT.md) for build, test, and local development instructions.

package/dist/src/bin/corum.js

@@ -1,10 +1,18 @@
+#!/usr/bin/env node
 import { Command } from 'commander';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { readFile as fsReadFile } from 'node:fs/promises';
 import path from 'node:path';
-import { loadImportConfig, buildOpenAPIConfig } from '../import/config.js';
+import { parse as parseYaml } from 'yaml';
+import { buildOpenAPIConfig, loadImportConfig } from '../import/config.js';
 import { runImport } from '../import/runner.js';
 import { loadGraph } from '../loader/index.js';
 import { startMcpServer } from '../mcp/index.js';
+import { parseGitHubRepo, toPackRawBaseUrl } from '../pack/github-urls.js';
+import { registerPackInGraph } from '../pack/graph-yaml.js';
+import { installPackFiles } from '../pack/installer.js';
+import { readManifest, upsertPack } from '../pack/manifest.js';
+import { fetchRegistry, findPack, resolveRef } from '../pack/registry.js';
 import { createGraphRuntimeConfig } from '../source/config.js';
 import { startWebServer } from '../web/server.js';
 const program = new Command();
@@ -12,7 +20,6 @@ program
     .name('corum')
     .description('Corum graph CLI')
     .version('0.1.0');
-// ── mcp ──────────────────────────────────────────────────────────────────────
 program
     .command('mcp')
     .description('Start the MCP stdio server (+ web UI by default)')
@@ -24,7 +31,6 @@ program
         process.env.CORUM_GRAPH_PATH = path.resolve(opts.graph);
     await startMcpServer({ noWeb: !opts.web, watch: opts.watch ?? false });
 });
-// ── web ──────────────────────────────────────────────────────────────────────
 program
     .command('web')
     .description('Start the web UI')
@@ -48,21 +54,23 @@ program
         port: opts.port,
     });
 });
-// ── init ─────────────────────────────────────────────────────────────────────
 const CONFIG_TEMPLATE = `# Corum project configuration
 # Uncomment and set the options relevant to your setup.
 # All values can be overridden by environment variables (CORUM_*) or CLI flags.
 
+# Registry URL for discovering and installing template packs.
+pack_registry: https://github.com/atolis-hq/corum/packs/registry.yaml
+
 # Source type: 'file' (default) or 'git'
 # Maps to: CORUM_SOURCE
 # source: file
 
-# ── File source (default) ─────────────────────────────────────────────────────
+# File source (default)
 # Local path to the graph directory.
 # Maps to: CORUM_GRAPH_PATH
 # graph: .corum/graph
 
-# ── Git source ────────────────────────────────────────────────────────────────
+# Git source
 # Uncomment 'source: git' above and configure one of the following:
 
 # Local path to a git repository containing the graph.
@@ -89,20 +97,47 @@ const CONFIG_TEMPLATE = `# Corum project configuration
 # Maps to: CORUM_GIT_USERNAME
 # git_username: x-access-token
 `;
+const GRAPH_TEMPLATE = `schema-version: '1.0'
+name: My Graph
+templatePacks: []
+components: []
+`;
 program
     .command('init')
-    .description('Scaffold .corum/config.yaml with commented defaults')
-    .action(() => {
-    const configPath = path.join(process.cwd(), '.corum', 'config.yaml');
+    .description('Scaffold .corum project structure and install default packs')
+    .action(async () => {
+    const cwd = process.cwd();
+    const corumDir = path.join(cwd, '.corum');
+    const configPath = path.join(corumDir, 'config.yaml');
+    const graphPath = path.join(corumDir, 'graph', 'graph.yaml');
     if (existsSync(configPath)) {
-        process.stdout.write(`.corum/config.yaml already exists — not overwriting\n`);
-        return;
+        process.stdout.write('.corum/config.yaml already exists - not overwriting\n');
+    }
+    else {
+        mkdirSync(path.dirname(configPath), { recursive: true });
+        writeFileSync(configPath, CONFIG_TEMPLATE);
+        process.stdout.write('Created .corum/config.yaml\n');
+    }
+    if (existsSync(graphPath)) {
+        process.stdout.write('.corum/graph/graph.yaml already exists - not overwriting\n');
+    }
+    else {
+        mkdirSync(path.dirname(graphPath), { recursive: true });
+        writeFileSync(graphPath, GRAPH_TEMPLATE);
+        mkdirSync(path.join(corumDir, 'graph', 'components'), { recursive: true });
+        mkdirSync(path.join(corumDir, 'graph', 'edges'), { recursive: true });
+        process.stdout.write('Created .corum/graph/graph.yaml\n');
+    }
+    for (const packName of ['core', 'domain', 'rest', 'messaging']) {
+        try {
+            await installPack(packName, cwd);
+        }
+        catch (err) {
+            process.stderr.write(`[ERROR] Failed to install pack ${packName}: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
     }
-    mkdirSync(path.dirname(configPath), { recursive: true });
-    writeFileSync(configPath, CONFIG_TEMPLATE);
-    process.stdout.write(`Created .corum/config.yaml\n`);
 });
-// ── import ───────────────────────────────────────────────────────────────────
 const importCmd = program.command('import')
     .description('Import specifications into the graph')
     .option('--config <path>', 'Path to import config YAML')
@@ -147,6 +182,38 @@ importCmd
         process.exit(2);
     }
 });
+const packCmd = program.command('pack').description('Manage template packs');
+packCmd
+    .command('install <name>')
+    .description('Install a pack from the registry (e.g. core, domain@v0.1.5)')
+    .action(async (name) => {
+    try {
+        await installPack(name);
+    }
+    catch (err) {
+        process.stderr.write(`[ERROR] ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    }
+});
+packCmd
+    .command('list')
+    .description('List installed packs')
+    .action(async () => {
+    try {
+        const manifest = await readManifest(path.join(process.cwd(), '.corum', 'packs.yaml'));
+        if (manifest.packs.length === 0) {
+            process.stdout.write('No packs installed. Run: corum pack install <name>\n');
+            return;
+        }
+        for (const p of manifest.packs) {
+            process.stdout.write(`${p.name}@${p.ref}  (${p.installedAt})\n`);
+        }
+    }
+    catch (err) {
+        process.stderr.write(`[ERROR] ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    }
+});
 function buildRuntimeConfig(graphOverride) {
     if (graphOverride)
         process.env.CORUM_GRAPH_PATH = path.resolve(graphOverride);
@@ -161,4 +228,33 @@ function reportDiagnostics(diagnostics) {
     const warnings = diagnostics.filter(d => d.severity === 'warning').length;
     process.stdout.write(`Import complete. ${errors} error(s), ${warnings} warning(s).\n`);
 }
+async function readPackRegistryUrl(cwd) {
+    const configPath = path.join(cwd, '.corum', 'config.yaml');
+    const text = await fsReadFile(configPath, 'utf8');
+    const config = parseYaml(text);
+    if (!config.pack_registry)
+        throw new Error('pack_registry not set in .corum/config.yaml - run corum init first');
+    return config.pack_registry;
+}
+export async function installPack(nameWithRef, cwd = process.cwd()) {
+    const atIdx = nameWithRef.indexOf('@');
+    const name = atIdx >= 0 ? nameWithRef.slice(0, atIdx) : nameWithRef;
+    const specifiedRef = atIdx >= 0 ? nameWithRef.slice(atIdx + 1) : undefined;
+    const registryUrl = await readPackRegistryUrl(cwd);
+    const registry = await fetchRegistry(registryUrl);
+    const pack = findPack(registry, name);
+    const { owner, repo } = parseGitHubRepo(pack.repo);
+    const ref = await resolveRef(owner, repo, specifiedRef);
+    const baseUrl = toPackRawBaseUrl(owner, repo, ref, pack.path);
+    await installPackFiles(baseUrl, path.join(cwd, '.corum', 'packs', name));
+    await upsertPack(path.join(cwd, '.corum', 'packs.yaml'), {
+        name,
+        repo: pack.repo,
+        path: pack.path,
+        ref,
+        installedAt: new Date().toISOString(),
+    });
+    await registerPackInGraph(path.join(cwd, '.corum', 'graph', 'graph.yaml'), name, `../packs/${name}`);
+    process.stdout.write(`Installed pack: ${name}@${ref}\n`);
+}
 program.parse();

package/dist/src/pack/github-urls.js

@@ -0,0 +1,30 @@
+export function parseGitHubUrl(url) {
+    const u = new URL(url);
+    if (u.hostname !== 'github.com')
+        throw new Error(`Not a github.com URL: ${url}`);
+    const segments = u.pathname.replace(/^\//, '').split('/').filter(Boolean);
+    if (segments.length < 3)
+        throw new Error(`Missing path in GitHub URL: ${url}`);
+    const [owner, repo, ...rest] = segments;
+    return { owner, repo, path: rest.join('/') };
+}
+export function parseGitHubRepo(repoUrl) {
+    const u = new URL(repoUrl);
+    if (u.hostname !== 'github.com')
+        throw new Error(`Not a github.com URL: ${repoUrl}`);
+    const segments = u.pathname.replace(/^\//, '').split('/').filter(Boolean);
+    if (segments.length < 2)
+        throw new Error(`Missing repository in GitHub URL: ${repoUrl}`);
+    const [owner, repo] = segments;
+    return { owner, repo };
+}
+export function toRegistryFetchUrl(configUrl) {
+    const { owner, repo, path } = parseGitHubUrl(configUrl);
+    return `https://raw.githubusercontent.com/${owner}/${repo}/HEAD/${path}`;
+}
+export function toPackRawBaseUrl(owner, repo, ref, packPath) {
+    return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${packPath}`;
+}
+export function toTagsApiUrl(owner, repo) {
+    return `https://api.github.com/repos/${owner}/${repo}/tags?per_page=1`;
+}

package/dist/src/pack/graph-yaml.js

@@ -0,0 +1,12 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { parse, stringify } from 'yaml';
+export async function registerPackInGraph(graphYamlPath, packName, relativePath) {
+    const text = await readFile(graphYamlPath, 'utf8');
+    const graph = parse(text);
+    if (!Array.isArray(graph.templatePacks))
+        graph.templatePacks = [];
+    if (graph.templatePacks.some(p => p.name === packName))
+        return;
+    graph.templatePacks.push({ name: packName, path: relativePath });
+    await writeFile(graphYamlPath, stringify(graph));
+}

package/dist/src/pack/installer.js

@@ -0,0 +1,20 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from 'yaml';
+export async function installPackFiles(baseUrl, destDir, fetchFn = fetch) {
+    const packYamlUrl = `${baseUrl}/pack.yaml`;
+    const packRes = await fetchFn(packYamlUrl);
+    if (!packRes.ok)
+        throw new Error(`Failed to fetch pack.yaml: ${packRes.status} ${packRes.statusText}`);
+    const packText = await packRes.text();
+    const meta = parse(packText);
+    await mkdir(path.join(destDir, 'templates'), { recursive: true });
+    await writeFile(path.join(destDir, 'pack.yaml'), packText);
+    for (const templateName of meta.templates) {
+        const templateUrl = `${baseUrl}/templates/${templateName}.yaml`;
+        const res = await fetchFn(templateUrl);
+        if (!res.ok)
+            throw new Error(`Failed to fetch template ${templateName}: ${res.status} ${res.statusText}`);
+        await writeFile(path.join(destDir, 'templates', `${templateName}.yaml`), await res.text());
+    }
+}

package/dist/src/pack/manifest.js

@@ -0,0 +1,26 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parse, stringify } from 'yaml';
+export async function readManifest(manifestPath) {
+    try {
+        const text = await readFile(manifestPath, 'utf8');
+        return parse(text) ?? { packs: [] };
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return { packs: [] };
+        throw err;
+    }
+}
+export async function upsertPack(manifestPath, entry) {
+    const manifest = await readManifest(manifestPath);
+    const idx = manifest.packs.findIndex(p => p.name === entry.name);
+    if (idx >= 0) {
+        manifest.packs[idx] = entry;
+    }
+    else {
+        manifest.packs.push(entry);
+    }
+    await mkdir(path.dirname(manifestPath), { recursive: true });
+    await writeFile(manifestPath, stringify(manifest));
+}

package/dist/src/pack/registry.js

@@ -0,0 +1,29 @@
+import { parse } from 'yaml';
+import { toRegistryFetchUrl, toTagsApiUrl } from './github-urls.js';
+export async function fetchRegistry(configUrl, fetchFn = fetch) {
+    const rawUrl = toRegistryFetchUrl(configUrl);
+    const res = await fetchFn(rawUrl);
+    if (!res.ok)
+        throw new Error(`Failed to fetch registry: ${res.status} ${res.statusText}`);
+    return parse(await res.text());
+}
+export function findPack(registry, name) {
+    const pack = registry.packs.find(p => p.name === name);
+    if (!pack) {
+        const available = registry.packs.map(p => p.name).join(', ');
+        throw new Error(`Pack "${name}" not found in registry. Available: ${available}`);
+    }
+    return pack;
+}
+export async function resolveRef(owner, repo, specifiedRef, fetchFn = fetch) {
+    if (specifiedRef)
+        return specifiedRef;
+    const url = toTagsApiUrl(owner, repo);
+    const res = await fetchFn(url);
+    if (!res.ok)
+        throw new Error(`Failed to resolve latest tag: ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    if (data.length === 0 || !data[0].name)
+        throw new Error(`Failed to resolve latest tag: no tags found for ${owner}/${repo}`);
+    return data[0].name;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/corum",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "repository": {
     "type": "git",