@mulmoclaude/core 0.2.14 → 0.2.16

package/dist/collection/registry/guards.d.ts

@@ -0,0 +1,2 @@
+/** Narrow `unknown` to a plain object (not null, not array). */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/collection/registry/index.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_types = require("../../types-CNqkLT4M.cjs");
+exports.OFFICIAL_REGISTRY_NAME = require_types.OFFICIAL_REGISTRY_NAME;
+exports.parseRegistryIndex = require_types.parseRegistryIndex;

package/dist/collection/registry/index.d.ts

@@ -0,0 +1,2 @@
+export { parseRegistryIndex, type RegistryEntry, type RegistryIndex, type ParseResult } from './registryIndex.js';
+export { OFFICIAL_REGISTRY_NAME, type RegistryConfigEntry, type RegistrySummary, type RegistryListResponse, type RegistryImportResponse } from './types.js';

package/dist/collection/registry/index.js

@@ -0,0 +1,2 @@
+import { n as parseRegistryIndex, t as OFFICIAL_REGISTRY_NAME } from "../../types-BKVZrtyc.js";
+export { OFFICIAL_REGISTRY_NAME, parseRegistryIndex };

package/dist/collection/registry/registryIndex.d.ts

@@ -0,0 +1,48 @@
+export interface RegistryEntry {
+    /** `<author>/<slug>` — identity inside its source registry. NOT globally
+     *  unique when multiple registries are configured — pair with `registryName`
+     *  for a global key. */
+    id: string;
+    author: string;
+    slug: string;
+    title: string;
+    icon: string;
+    description: string;
+    version: string;
+    tags: string[];
+    license: string;
+    fieldCount: number;
+    /** Custom view labels. */
+    views: string[];
+    hasSeed: boolean;
+    seedCount: number;
+    /** repo-relative path, omitted when absent. */
+    screenshot?: string;
+    /** repo-relative collection dir. */
+    path: string;
+    /** Stable bundle hash for update detection. */
+    contentSha: string;
+    /** Label of the source registry. Set by the client (not by the parser) when
+     *  the index is fetched, so the import / preview path can resolve the right
+     *  rawBase. `"official"` for receptron/mulmoclaude-collections; otherwise
+     *  the user's config entry name. */
+    registryName: string;
+}
+export interface RegistryIndex {
+    schemaVersion: number;
+    generatedAt: string;
+    registry: string;
+    collections: RegistryEntry[];
+}
+export type ParseResult = {
+    ok: true;
+    index: RegistryIndex;
+} | {
+    ok: false;
+    error: string;
+};
+/** Parse an index payload. `registryName` labels every entry produced — the
+ *  caller passes "official" for the canonical registry or the user's config
+ *  entry name. The label is needed downstream so import / preview can pick the
+ *  right rawBase for per-collection files. */
+export declare function parseRegistryIndex(value: unknown, registryName: string): ParseResult;

package/dist/collection/registry/server/client.d.ts

@@ -0,0 +1,60 @@
+import { RegistryEntry, RegistryIndex } from '../registryIndex.js';
+import { RegistryConfigEntry } from './registriesConfig.js';
+export declare const CACHE_TTL_MS: number;
+export declare const STALE_RETRY_BACKOFF_MS: number;
+/** Per-registry fetch outcome. `ok: false` is reported per-registry — the
+ *  merged Discover response still succeeds when at least one registry is
+ *  reachable; failed registries just contribute zero entries. */
+export type FetchIndexResult = {
+    ok: true;
+    index: RegistryIndex;
+    stale: boolean;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+/** Resolved descriptor for one registry the host should fetch — name + URLs.
+ *  `official` is always synthesized; further entries come from
+ *  `config/collections-registries.json`. Currently structurally identical to
+ *  `RegistryConfigEntry`; aliased so we can add server-only fields (e.g.
+ *  auth headers) without touching the on-disk config schema. */
+export type RegistryDescriptor = RegistryConfigEntry;
+/** The full ordered registry list: official first, then user-configured ones.
+ *  Re-reads the config file on every call so a Discover refresh picks up edits
+ *  without a server restart (the config is small + read-rarely). */
+export declare function listRegistries(): RegistryDescriptor[];
+/** Look up one registry descriptor by name. Used by the preview / import path,
+ *  which has the registry label from the entry and needs the rawBase. */
+export declare function findRegistry(name: string): RegistryDescriptor | null;
+export type IndexLoader = (descriptor: RegistryDescriptor) => Promise<FetchIndexResult>;
+/** Fetch one registry's index. Same cache + stale-on-failure semantics as the
+ *  original single-registry implementation — just keyed by descriptor identity
+ *  (name + both URLs) so multiple registries don't fight over one slot AND a
+ *  reconfigured registry doesn't serve a stale index from the prior URL. */
+export declare function fetchRegistryIndex(descriptor: RegistryDescriptor, opts?: {
+    force?: boolean;
+    nowMs?: number;
+    loader?: IndexLoader;
+}): Promise<FetchIndexResult>;
+/** One registry's contribution to the merged Discover view. `failed` registries
+ *  surface in the response so the UI can show a per-registry error badge while
+ *  still rendering the entries from the registries that did work. */
+export interface MergedRegistryResult {
+    name: string;
+    status: "ok" | "stale" | "failed";
+    generatedAt: string | null;
+    error: string | null;
+    entries: RegistryEntry[];
+}
+/** Fetch every configured registry in parallel and return per-registry
+ *  outcomes. Callers (the Discover route) concatenate `entries` from each.
+ *  Failure of any single registry doesn't abort the others — that's the point
+ *  of supporting multiple registries. */
+export declare function fetchAllRegistries(opts?: {
+    force?: boolean;
+    nowMs?: number;
+    loader?: IndexLoader;
+}): Promise<MergedRegistryResult[]>;
+/** Test seam: reset the module cache + failure backoff state (all registries). */
+export declare function resetRegistryCache(): void;

package/dist/collection/registry/server/collectionFiles.d.ts

@@ -0,0 +1,51 @@
+import { RegistryEntry } from '../registryIndex.js';
+/** Compose the raw URL for `<dirPath>/<relFile>` under a given registry's
+ *  rawBase. Empty and traversal (`.`/`..`) segments are dropped so the URL can
+ *  never escape the base, even if an upstream check is bypassed (the index
+ *  parser already rejects such identifiers — this is defense-in-depth). The
+ *  rawBase is trailing-slash-normalized: `parseRegistriesConfig` already trims
+ *  user-config trailing slashes, but the official descriptor and any test
+ *  bypass parse — repeating the trim here keeps the join `${base}/${path}`
+ *  from producing `//` even when the caller bypassed config validation
+ *  (CodeRabbit review on #1837). */
+export declare function collectionFileUrl(rawBase: string, dirPath: string, relFile: string): string;
+export type FileResult = {
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+/** Fetch one file out of a registry collection. `rawBase` comes from the
+ *  entry's source registry (`findRegistry(entry.registryName).rawBaseUrl`),
+ *  not a module-level setting — that's what makes additional user-configured
+ *  registries reachable. */
+export declare function fetchCollectionFile(rawBase: string, dirPath: string, relFile: string): Promise<FileResult>;
+export type JsonObjectResult = {
+    ok: true;
+    value: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseJsonObject(text: string, label: string): JsonObjectResult;
+/** Resolve an entry's rawBase from its `registryName`. A missing match (the
+ *  user removed the registry from config while a cached index still references
+ *  it) returns null — the caller surfaces it as a 404 rather than crashing. */
+export declare function rawBaseForEntry(entry: Pick<RegistryEntry, "registryName">): string | null;
+export type PreviewResult = {
+    ok: true;
+    entry: RegistryEntry;
+    schema: Record<string, unknown>;
+    meta: Record<string, unknown>;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+/** Preview a registry collection: confirm it's in some registry's published
+ *  index, then fetch + parse its schema.json + meta.json so the Discover tab
+ *  can show fields/views before import. With multi-registry support the
+ *  `registry` arg disambiguates same-name collections from different sources. */
+export declare function previewCollection(author: string, slug: string, registry?: string | null): Promise<PreviewResult>;

package/dist/collection/registry/server/exportCollection.d.ts

@@ -0,0 +1,29 @@
+export declare const EXPORT_BASE = "data/registry-export";
+export interface ExportMeta {
+    author: string;
+    slug: string;
+    version: string;
+    title: string;
+    description: string;
+    tags: string[];
+    license: string;
+}
+export type ExportResult = {
+    ok: true;
+    outputPath: string;
+    fileCount: number;
+    seedCount: number;
+    seedSkipped: number;
+    warnings: string[];
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+export declare function writeCollectionExport(params: {
+    workspaceRoot: string;
+    skillDir: string;
+    dataDir: string;
+    meta: ExportMeta;
+    includeSeed: boolean;
+}): Promise<ExportResult>;

package/dist/collection/registry/server/fetch.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_FETCH_TIMEOUT_MS: number;
+export type FetchWithTimeoutInit = Parameters<typeof fetch>[1] & {
+    timeoutMs?: number;
+};
+/** `fetch` with a finite timeout. Rejects with a `TimeoutError` once `timeoutMs`
+ *  elapses. Composes with a caller-supplied `signal` so external cancellation
+ *  still works. */
+export declare function fetchWithTimeout(url: string | URL, init?: FetchWithTimeoutInit): Promise<Response>;

package/dist/collection/registry/server/importCollection.d.ts

@@ -0,0 +1,35 @@
+import { RegistryEntry } from '../registryIndex.js';
+/** A manifest entry must be a relative path that stays inside the collection dir:
+ *  no absolute paths, no backslashes, no empty / `.` / `..` segments. */
+export declare function isSafeBundlePath(rel: unknown): rel is string;
+export type ManifestResult = {
+    ok: true;
+    files: string[];
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseManifest(value: unknown): ManifestResult;
+/** `data/collections/<localSlug>/items` — the host owns dataPath, never the
+ *  registry's authored value, so imported collections can't collide on disk. */
+export declare function normalizedDataPath(localSlug: string): string;
+export declare function withNormalizedDataPath(schema: Record<string, unknown>, localSlug: string): Record<string, unknown>;
+export type ManifestFetch = {
+    ok: true;
+    files: string[];
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+export declare function fetchManifest(entry: RegistryEntry): Promise<ManifestFetch>;
+export type BundleFetch = {
+    ok: true;
+    files: Map<string, string>;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+/** Fetch every manifest file. Paths are already safety-checked by parseManifest. */
+export declare function fetchBundle(entry: RegistryEntry, fileList: readonly string[]): Promise<BundleFetch>;

package/dist/collection/registry/server/importWriter.d.ts

@@ -0,0 +1,30 @@
+import { claudeSkillDir, dataSkillDir } from '../../../skill-bridge/index.js';
+import { RegistryEntry } from '../registryIndex.js';
+export interface ImportOrigin {
+    registry: string;
+    author: string;
+    slug: string;
+    version: string;
+    contentSha: string;
+    importedAt: string;
+}
+export type ImportResult = {
+    ok: true;
+    localSlug: string;
+    updated: boolean;
+    seedWritten: number;
+    seedSkipped: boolean;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+export declare function writeImportedCollection(params: {
+    registry: string;
+    entry: RegistryEntry;
+    bundle: Map<string, string>;
+    workspaceRoot: string;
+    nowIso: string;
+}): Promise<ImportResult>;
+export declare function performImport(author: string, slug: string, workspaceRoot: string, registry?: string | null): Promise<ImportResult>;
+export { claudeSkillDir, dataSkillDir };