agentikit 0.0.9 → 0.0.12

package/dist/src/registry-search.js

@@ -1,128 +1,262 @@
-const GITHUB_API_BASE = "https://api.github.com";
+import fs from "node:fs";
+import path from "node:path";
+import { fetchWithTimeout } from "./common";
+// ── Constants ───────────────────────────────────────────────────────────────
+/** Default registry index URL. Override via config or AKM_REGISTRY_URL env var. */
+const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/itlackey/agentikit-registry/main/index.json";
+/** Cache TTL in milliseconds (1 hour). */
+const CACHE_TTL_MS = 60 * 60 * 1000;
+/** Maximum age before cache is considered stale but still usable as fallback (7 days). */
+const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
+// ── Public API ──────────────────────────────────────────────────────────────
 export async function searchRegistry(query, options) {
     const trimmed = query.trim();
     if (!trimmed) {
         return { query: "", hits: [], warnings: [] };
     }
     const limit = clampLimit(options?.limit);
-    const [npmResult, githubResult] = await Promise.allSettled([
-        searchNpm(trimmed, limit),
-        searchGithub(trimmed, limit),
-    ]);
-    const hits = [];
+    const urls = resolveRegistryUrls(options?.registryUrls);
     const warnings = [];
-    if (npmResult.status === "fulfilled") {
-        hits.push(...npmResult.value);
+    // Load index from all configured registries, merge kits
+    const allKits = [];
+    for (const url of urls) {
+        try {
+            const index = await loadIndex(url);
+            if (index) {
+                allKits.push(...index.kits);
+            }
+        }
+        catch (err) {
+            warnings.push(`Registry ${url}: ${toErrorMessage(err)}`);
+        }
     }
-    else {
-        warnings.push(`npm search failed: ${toErrorMessage(npmResult.reason)}`);
+    // Score and rank
+    const hits = scoreKits(allKits, trimmed, limit);
+    return { query: trimmed, hits, warnings };
+}
+// ── Index loading with cache ────────────────────────────────────────────────
+async function loadIndex(url) {
+    const cachePath = indexCachePath(url);
+    const cached = readCachedIndex(cachePath);
+    // Fresh cache: return immediately
+    if (cached && !isCacheExpired(cached.mtime)) {
+        return cached.index;
+    }
+    // Try to fetch fresh index
+    try {
+        const response = await fetchWithTimeout(url, undefined, 10_000);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = (await response.json());
+        const index = parseRegistryIndex(data);
+        if (index) {
+            writeCachedIndex(cachePath, index);
+            return index;
+        }
+        throw new Error("Invalid registry index format");
+    }
+    catch (err) {
+        // Fetch failed — use stale cache if available
+        if (cached && !isCacheStale(cached.mtime)) {
+            return cached.index;
+        }
+        throw err;
+    }
+}
+function readCachedIndex(cachePath) {
+    try {
+        const stat = fs.statSync(cachePath);
+        const raw = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+        const index = parseRegistryIndex(raw);
+        if (!index)
+            return null;
+        return { index, mtime: stat.mtimeMs };
+    }
+    catch {
+        return null;
     }
-    if (githubResult.status === "fulfilled") {
-        hits.push(...githubResult.value);
+}
+function writeCachedIndex(cachePath, index) {
+    try {
+        const dir = path.dirname(cachePath);
+        fs.mkdirSync(dir, { recursive: true });
+        const tmpPath = cachePath + `.tmp.${process.pid}`;
+        fs.writeFileSync(tmpPath, JSON.stringify(index), "utf8");
+        fs.renameSync(tmpPath, cachePath);
     }
-    else {
-        warnings.push(`GitHub search failed: ${toErrorMessage(githubResult.reason)}`);
+    catch {
+        // Best-effort caching — don't fail the search if we can't write
     }
-    hits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+}
+function indexCachePath(url) {
+    const cacheRoot = resolveCacheDir();
+    // Deterministic filename from URL
+    const slug = url
+        .replace(/[^a-zA-Z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 120);
+    return path.join(cacheRoot, "registry-index", `${slug}.json`);
+}
+function resolveCacheDir() {
+    const xdgCache = process.env.XDG_CACHE_HOME?.trim();
+    if (xdgCache)
+        return path.join(path.resolve(xdgCache), "agentikit");
+    const home = process.env.HOME?.trim();
+    if (!home)
+        return path.join("/tmp", "agentikit-cache");
+    return path.join(path.resolve(home), ".cache", "agentikit");
+}
+function isCacheExpired(mtimeMs) {
+    return Date.now() - mtimeMs > CACHE_TTL_MS;
+}
+function isCacheStale(mtimeMs) {
+    return Date.now() - mtimeMs > CACHE_STALE_MS;
+}
+// ── Index parsing ───────────────────────────────────────────────────────────
+function parseRegistryIndex(data) {
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+        return null;
+    const obj = data;
+    if (typeof obj.version !== "number" || obj.version !== 1)
+        return null;
+    if (typeof obj.updatedAt !== "string")
+        return null;
+    if (!Array.isArray(obj.kits))
+        return null;
+    const kits = obj.kits.flatMap((raw) => {
+        const kit = parseKitEntry(raw);
+        return kit ? [kit] : [];
+    });
+    return { version: 1, updatedAt: obj.updatedAt, kits };
+}
+function parseKitEntry(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const id = asString(obj.id);
+    const name = asString(obj.name);
+    const ref = asString(obj.ref);
+    const source = asSource(obj.source);
+    if (!id || !name || !ref || !source)
+        return null;
     return {
-        query: trimmed,
-        hits: hits.slice(0, limit * 2),
-        warnings,
+        id,
+        name,
+        ref,
+        source,
+        description: asString(obj.description),
+        homepage: asString(obj.homepage),
+        tags: asStringArray(obj.tags),
+        assetTypes: asStringArray(obj.assetTypes),
+        author: asString(obj.author),
+        license: asString(obj.license),
+        latestVersion: asString(obj.latestVersion),
+        curated: obj.curated === true ? true : undefined,
     };
 }
-async function searchNpm(query, limit) {
-    const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(query)}&size=${limit}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
+// ── Scoring ─────────────────────────────────────────────────────────────────
+function scoreKits(kits, query, limit) {
+    const tokens = query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+    const scored = [];
+    for (const kit of kits) {
+        const score = scoreKit(kit, tokens);
+        if (score > 0) {
+            scored.push({ kit, score });
+        }
     }
-    const data = await response.json();
-    const objects = Array.isArray(data.objects) ? data.objects : [];
-    return objects.flatMap((raw) => {
-        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
-            return [];
-        const obj = raw;
-        const pkg = asRecord(obj.package);
-        const name = asString(pkg.name);
-        if (!name)
-            return [];
-        const version = asString(pkg.version);
-        const metadata = {};
-        if (version)
-            metadata.version = version;
-        const date = asString(pkg.date);
-        if (date)
-            metadata.updatedAt = date;
-        return [{
-                source: "npm",
-                id: `npm:${name}`,
-                title: name,
-                description: asString(pkg.description),
-                ref: name,
-                homepage: asString(asRecord(pkg.links).homepage),
-                score: asNumber(obj.score),
-                metadata,
-            }];
-    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map(({ kit, score }) => toSearchHit(kit, score));
 }
-async function searchGithub(query, limit) {
-    const q = encodeURIComponent(`${query} in:name,description,readme`);
-    const url = `${GITHUB_API_BASE}/search/repositories?q=${q}&sort=stars&order=desc&per_page=${limit}`;
-    const response = await fetch(url, { headers: githubHeaders() });
-    if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
+function scoreKit(kit, tokens) {
+    let score = 0;
+    const nameLower = kit.name.toLowerCase();
+    const descLower = (kit.description ?? "").toLowerCase();
+    const tagsLower = (kit.tags ?? []).map((t) => t.toLowerCase());
+    for (const token of tokens) {
+        // Exact name match is strongest signal
+        if (nameLower === token) {
+            score += 1.0;
+        }
+        else if (nameLower.includes(token)) {
+            score += 0.6;
+        }
+        // Tag matches are high-signal (curated keywords)
+        if (tagsLower.some((tag) => tag === token)) {
+            score += 0.5;
+        }
+        else if (tagsLower.some((tag) => tag.includes(token))) {
+            score += 0.25;
+        }
+        // Description substring
+        if (descLower.includes(token)) {
+            score += 0.2;
+        }
+        // Author match
+        if (kit.author?.toLowerCase().includes(token)) {
+            score += 0.15;
+        }
     }
-    const data = await response.json();
-    const items = Array.isArray(data.items) ? data.items : [];
-    return items.flatMap((raw) => {
-        const repo = asRecord(raw);
-        const fullName = asString(repo.full_name);
-        if (!fullName)
-            return [];
-        const metadata = {};
-        const stars = asNumber(repo.stargazers_count);
-        if (stars > 0)
-            metadata.stars = String(stars);
-        const language = asString(repo.language);
-        if (language)
-            metadata.language = language;
-        return [{
-                source: "github",
-                id: `github:${fullName}`,
-                title: fullName,
-                description: asString(repo.description),
-                ref: fullName,
-                homepage: asString(repo.html_url),
-                score: stars,
-                metadata,
-            }];
-    });
+    // Normalize by token count so multi-word queries don't inflate scores
+    return tokens.length > 0 ? score / tokens.length : 0;
 }
-function githubHeaders() {
-    const token = process.env.GITHUB_TOKEN?.trim();
-    const headers = {
-        Accept: "application/vnd.github+json",
-        "User-Agent": "agentikit-registry",
+function toSearchHit(kit, score) {
+    const metadata = {};
+    if (kit.latestVersion)
+        metadata.version = kit.latestVersion;
+    if (kit.author)
+        metadata.author = kit.author;
+    if (kit.license)
+        metadata.license = kit.license;
+    if (kit.assetTypes?.length)
+        metadata.assetTypes = kit.assetTypes.join(", ");
+    return {
+        source: kit.source,
+        id: kit.id,
+        title: kit.name,
+        description: kit.description,
+        ref: kit.ref,
+        homepage: kit.homepage,
+        score: Math.round(score * 1000) / 1000,
+        metadata,
+        curated: kit.curated,
     };
-    if (token)
-        headers.Authorization = `Bearer ${token}`;
-    return headers;
 }
+// ── Registry URL resolution ─────────────────────────────────────────────────
+function resolveRegistryUrls(override) {
+    if (override) {
+        const urls = Array.isArray(override) ? override : [override];
+        return urls.filter(Boolean);
+    }
+    // Allow env var override (comma-separated)
+    const envUrls = process.env.AKM_REGISTRY_URL?.trim();
+    if (envUrls) {
+        return envUrls.split(",").map((u) => u.trim()).filter(Boolean);
+    }
+    return [DEFAULT_REGISTRY_URL];
+}
+// ── Utilities ───────────────────────────────────────────────────────────────
 function clampLimit(limit) {
     if (!limit || !Number.isFinite(limit))
         return 20;
     return Math.min(100, Math.max(1, Math.trunc(limit)));
 }
-function asRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : {};
-}
 function asString(value) {
     return typeof value === "string" && value ? value : undefined;
 }
-function asNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+function asSource(value) {
+    return value === "npm" || value === "github" || value === "git"
+        ? value
+        : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const filtered = value.filter((v) => typeof v === "string");
+    return filtered.length > 0 ? filtered : undefined;
 }
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);

package/dist/src/registry-types.d.ts

@@ -1,4 +1,4 @@
-export type RegistrySource = "npm" | "github";
+export type RegistrySource = "npm" | "github" | "git";
 export interface RegistryRefBase {
     source: RegistrySource;
     ref: string;
@@ -15,7 +15,12 @@ export interface ParsedGithubRef extends RegistryRefBase {
     repo: string;
     requestedRef?: string;
 }
-export type ParsedRegistryRef = ParsedNpmRef | ParsedGithubRef;
+export interface ParsedGitRef extends RegistryRefBase {
+    source: "git";
+    repoRoot: string;
+    sourcePath: string;
+}
+export type ParsedRegistryRef = ParsedNpmRef | ParsedGithubRef | ParsedGitRef;
 export interface ResolvedRegistryArtifact {
     id: string;
     source: RegistrySource;
@@ -47,6 +52,8 @@ export interface RegistrySearchHit {
     homepage?: string;
     score?: number;
     metadata?: Record<string, string>;
+    /** Whether this entry was manually reviewed and approved */
+    curated?: boolean;
 }
 export interface RegistrySearchResponse {
     query: string;

package/dist/src/stash-add.js

@@ -6,10 +6,10 @@ import { upsertInstalledRegistryEntry, installRegistryRef } from "./registry-ins
 export async function agentikitAdd(input) {
     const ref = input.ref.trim();
     if (!ref)
-        throw new Error("Registry ref is required.");
+        throw new Error("Install ref or local git directory is required.");
     const stashDir = resolveStashDir();
     const installed = await installRegistryRef(ref);
-    const replaced = loadConfig(stashDir).registry?.installed.find((entry) => entry.id === installed.id);
+    const replaced = loadConfig().registry?.installed.find((entry) => entry.id === installed.id);
     const config = upsertInstalledRegistryEntry({
         id: installed.id,
         source: installed.source,
@@ -20,7 +20,7 @@ export async function agentikitAdd(input) {
         stashRoot: installed.stashRoot,
         cacheDir: installed.cacheDir,
         installedAt: installed.installedAt,
-    }, stashDir);
+    });
     if (replaced && replaced.cacheDir !== installed.cacheDir) {
         try {
             fs.rmSync(replaced.cacheDir, { recursive: true, force: true });
@@ -46,7 +46,7 @@ export async function agentikitAdd(input) {
             installedAt: installed.installedAt,
         },
         config: {
-            additionalStashDirs: config.additionalStashDirs,
+            mountedStashDirs: config.mountedStashDirs,
             installedRegistryCount: config.registry?.installed.length ?? 0,
         },
         index: {

package/dist/src/stash-clone.d.ts

@@ -0,0 +1,22 @@
+import { type StashSourceKind } from "./stash-source";
+export interface CloneOptions {
+    /** Source ref (e.g., npm:@scope/pkg//tool:deploy.sh) */
+    sourceRef: string;
+    /** Optional new name for the cloned asset */
+    newName?: string;
+    /** If true, overwrite existing asset in working stash */
+    force?: boolean;
+}
+export interface CloneResponse {
+    source: {
+        path: string;
+        sourceKind: StashSourceKind;
+        registryId?: string;
+    };
+    destination: {
+        path: string;
+        ref: string;
+    };
+    overwritten: boolean;
+}
+export declare function agentikitClone(options: CloneOptions): Promise<CloneResponse>;

package/dist/src/stash-clone.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import { TYPE_DIRS } from "./asset-spec";
+import { parseAssetRef, makeAssetRef } from "./stash-ref";
+import { resolveSourcesForOrigin } from "./origin-resolve";
+import { resolveAssetPath } from "./stash-resolve";
+import { resolveStashSources, findSourceForPath } from "./stash-source";
+export async function agentikitClone(options) {
+    const parsed = parseAssetRef(options.sourceRef);
+    const allSources = resolveStashSources();
+    const workingSource = allSources.find((s) => s.kind === "working");
+    if (!workingSource) {
+        throw new Error("No working stash configured. Run `akm init` first.");
+    }
+    const searchSources = resolveSourcesForOrigin(parsed.origin, allSources);
+    let sourcePath;
+    let lastError;
+    for (const source of searchSources) {
+        try {
+            sourcePath = resolveAssetPath(source.path, parsed.type, parsed.name);
+            break;
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+        }
+    }
+    if (!sourcePath) {
+        throw lastError ?? new Error(`Source asset not found for ref: ${options.sourceRef}`);
+    }
+    const sourceSource = findSourceForPath(sourcePath, allSources);
+    const sourceKind = sourceSource?.kind ?? "working";
+    const destName = options.newName ?? parsed.name;
+    const typeDir = TYPE_DIRS[parsed.type];
+    const workingDir = workingSource.path;
+    // Guard against self-clone
+    if (parsed.type === "skill") {
+        const sourceSkillDir = path.resolve(path.dirname(sourcePath));
+        const destSkillDir = path.resolve(path.join(workingDir, typeDir, destName));
+        if (sourceSkillDir === destSkillDir) {
+            throw new Error(`Source and destination are the same path. Use --name to provide a new name for the clone.`);
+        }
+    }
+    else {
+        const resolvedSource = path.resolve(sourcePath);
+        const resolvedDest = path.resolve(path.join(workingDir, typeDir, destName));
+        if (resolvedSource === resolvedDest) {
+            throw new Error(`Source and destination are the same path. Use --name to provide a new name for the clone.`);
+        }
+    }
+    let destPath;
+    if (parsed.type === "skill") {
+        const sourceSkillDir = path.dirname(sourcePath);
+        const destSkillDir = path.join(workingDir, typeDir, destName);
+        const overwritten = fs.existsSync(destSkillDir);
+        if (overwritten && !options.force) {
+            throw new Error(`Asset already exists in working stash: ${destSkillDir}. Use --force to overwrite.`);
+        }
+        if (overwritten) {
+            fs.rmSync(destSkillDir, { recursive: true, force: true });
+        }
+        fs.cpSync(sourceSkillDir, destSkillDir, { recursive: true });
+        destPath = path.join(destSkillDir, "SKILL.md");
+        const ref = makeAssetRef(parsed.type, destName, "local");
+        return {
+            source: { path: sourcePath, sourceKind, registryId: sourceSource?.registryId },
+            destination: { path: destPath, ref },
+            overwritten,
+        };
+    }
+    destPath = path.join(workingDir, typeDir, destName);
+    const overwritten = fs.existsSync(destPath);
+    if (overwritten && !options.force) {
+        throw new Error(`Asset already exists in working stash: ${destPath}. Use --force to overwrite.`);
+    }
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.copyFileSync(sourcePath, destPath);
+    const ref = makeAssetRef(parsed.type, destName, "local");
+    return {
+        source: { path: sourcePath, sourceKind, registryId: sourceSource?.registryId },
+        destination: { path: destPath, ref },
+        overwritten,
+    };
+}

package/dist/src/stash-ref.d.ts

@@ -1,7 +1,31 @@
 import { type AgentikitAssetType } from "./common";
-export interface OpenRef {
+export interface AssetRef {
     type: AgentikitAssetType;
     name: string;
+    /**
+     * Where to find this asset.
+     *   - undefined: search all sources (working → mounted → installed)
+     *   - "local": working stash only
+     *   - registry ref: e.g. "npm:@scope/pkg", "owner/repo", "github:owner/repo#v1"
+     *   - filesystem path: e.g. "/mnt/shared-stash"
+     */
+    origin?: string;
 }
-export declare function parseOpenRef(ref: string): OpenRef;
-export declare function makeOpenRef(type: AgentikitAssetType, name: string): string;
+/**
+ * Build a ref string from components.
+ *
+ * Examples:
+ *   makeAssetRef("tool", "deploy.sh")
+ *     → "tool:deploy.sh"
+ *   makeAssetRef("tool", "deploy.sh", "npm:@scope/pkg")
+ *     → "npm:@scope/pkg//tool:deploy.sh"
+ *   makeAssetRef("skill", "code-review", "local")
+ *     → "local//skill:code-review"
+ *   makeAssetRef("tool", "db/migrate/run.sh", "owner/repo")
+ *     → "owner/repo//tool:db/migrate/run.sh"
+ */
+export declare function makeAssetRef(type: AgentikitAssetType, name: string, origin?: string): string;
+/**
+ * Parse a ref string in the format `[origin//]type:name`.
+ */
+export declare function parseAssetRef(ref: string): AssetRef;

package/dist/src/stash-ref.js

@@ -1,33 +1,72 @@
 import path from "node:path";
 import { isAssetType } from "./common";
-export function parseOpenRef(ref) {
-    const separator = ref.indexOf(":");
-    if (separator <= 0) {
-        throw new Error("Invalid open ref. Expected format '<type>:<name>'.");
-    }
-    const rawType = ref.slice(0, separator);
-    const rawName = ref.slice(separator + 1);
-    if (!isAssetType(rawType)) {
-        throw new Error(`Invalid open ref type: "${rawType}".`);
+// ── Construction ────────────────────────────────────────────────────────────
+/**
+ * Build a ref string from components.
+ *
+ * Examples:
+ *   makeAssetRef("tool", "deploy.sh")
+ *     → "tool:deploy.sh"
+ *   makeAssetRef("tool", "deploy.sh", "npm:@scope/pkg")
+ *     → "npm:@scope/pkg//tool:deploy.sh"
+ *   makeAssetRef("skill", "code-review", "local")
+ *     → "local//skill:code-review"
+ *   makeAssetRef("tool", "db/migrate/run.sh", "owner/repo")
+ *     → "owner/repo//tool:db/migrate/run.sh"
+ */
+export function makeAssetRef(type, name, origin) {
+    validateName(name);
+    const normalized = normalizeName(name);
+    const asset = `${type}:${normalized}`;
+    if (!origin)
+        return asset;
+    return `${origin}//${asset}`;
+}
+// ── Parsing ─────────────────────────────────────────────────────────────────
+/**
+ * Parse a ref string in the format `[origin//]type:name`.
+ */
+export function parseAssetRef(ref) {
+    const trimmed = ref.trim();
+    if (!trimmed)
+        throw new Error("Empty ref.");
+    let origin;
+    let body = trimmed;
+    const boundary = trimmed.indexOf("//");
+    if (boundary >= 0) {
+        origin = trimmed.slice(0, boundary);
+        body = trimmed.slice(boundary + 2);
+        if (!origin)
+            throw new Error("Empty origin in ref.");
     }
-    let name;
-    try {
-        name = decodeURIComponent(rawName);
+    const colon = body.indexOf(":");
+    if (colon <= 0) {
+        throw new Error(`Invalid ref "${trimmed}". Expected [origin//]type:name`);
     }
-    catch {
-        throw new Error("Invalid open ref encoding.");
+    const rawType = body.slice(0, colon);
+    const rawName = body.slice(colon + 1);
+    if (!isAssetType(rawType)) {
+        throw new Error(`Invalid asset type: "${rawType}".`);
     }
+    validateName(rawName);
+    const name = normalizeName(rawName);
+    return { type: rawType, name, origin: origin || undefined };
+}
+// ── Validation ──────────────────────────────────────────────────────────────
+function validateName(name) {
+    if (!name)
+        throw new Error("Empty asset name.");
+    if (name.includes("\0"))
+        throw new Error("Null byte in asset name.");
+    if (/^[A-Za-z]:/.test(name))
+        throw new Error("Windows drive path in asset name.");
     const normalized = path.posix.normalize(name.replace(/\\/g, "/"));
-    if (!name
-        || name.includes("\0")
-        || /^[A-Za-z]:/.test(name)
-        || path.posix.isAbsolute(normalized)
-        || normalized === ".."
-        || normalized.startsWith("../")) {
-        throw new Error("Invalid open ref name.");
+    if (path.posix.isAbsolute(normalized))
+        throw new Error("Absolute path in asset name.");
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error("Path traversal in asset name.");
     }
-    return { type: rawType, name: normalized };
 }
-export function makeOpenRef(type, name) {
-    return `${type}:${encodeURIComponent(name)}`;
+function normalizeName(name) {
+    return path.posix.normalize(name.replace(/\\/g, "/"));
 }