@happyvertical/smrt-planner 0.0.0-stage → 0.0.1

package/dist/catalog/generate/build.d.ts

@@ -0,0 +1,33 @@
+import type { Catalog, CatalogPackage } from '../types.ts';
+import { type RawPackage } from './extract.ts';
+export interface BuildOptions {
+    registry: string;
+    /**
+     * Path to a smrt checkout: read its built `packages/*\/dist/manifest.json`
+     * instead of the registry, to preview unreleased manifests. Opt-in.
+     */
+    source?: string;
+    log?: (message: string) => void;
+}
+/**
+ * Turn raw packages into the catalog: drop the documented exclusions and
+ * packages with no models, extract the rest, and sort. A package on the
+ * exclusion list that declares recipes stays: a recipe is a feature a visitor
+ * can pick (the assistant is `smrt-chat`'s), whatever else the package is.
+ * Output order is sorted, with no timestamps, so a run against the same inputs
+ * is byte-identical. Pure: no network or disk access.
+ */
+export declare function assembleCatalog(raws: readonly RawPackage[], registry: string, log?: (message: string) => void): Catalog;
+/**
+ * Drop the recipes a browser mock-up cannot show: one that lists a model no
+ * catalog package declares, or whose menu opens a model with no screen (not
+ * exposed), or that needs a recipe dropped for either reason. A package left
+ * with no recipe and no exposed model has nothing to pick and goes too. Every
+ * drop is logged; the reasons are the manifest's, so the fix is upstream.
+ */
+export declare function dropUnrenderableRecipes(packages: readonly CatalogPackage[], log?: (message: string) => void): CatalogPackage[];
+/**
+ * Build the catalog from the registry (discover every `smrt-*` package), or,
+ * when `source` is set, from a local smrt checkout's built manifests.
+ */
+export declare function buildCatalog(options: BuildOptions): Promise<Catalog>;

package/dist/catalog/generate/build.js

@@ -0,0 +1,131 @@
+import { EXCLUDED_PACKAGES } from "./exclusions.js";
+import { extractPackage, packageId, resolveDependencies, } from "./extract.js";
+import { readLocalPackages } from "./local.js";
+import { withEffectiveDemo } from "./recipe-demo.js";
+import { discoverPackageNames, fetchPackage } from "./registry.js";
+/**
+ * Turn raw packages into the catalog: drop the documented exclusions and
+ * packages with no models, extract the rest, and sort. A package on the
+ * exclusion list that declares recipes stays: a recipe is a feature a visitor
+ * can pick (the assistant is `smrt-chat`'s), whatever else the package is.
+ * Output order is sorted, with no timestamps, so a run against the same inputs
+ * is byte-identical. Pure: no network or disk access.
+ */
+export function assembleCatalog(raws, registry, log = () => { }) {
+    const extracted = [];
+    for (const raw of raws) {
+        const excluded = EXCLUDED_PACKAGES[packageId(raw.packageName)];
+        const pkg = extractPackage(raw);
+        if (excluded && !pkg.recipes) {
+            log(`exclude ${raw.packageName}: ${excluded}`);
+            continue;
+        }
+        if (pkg.models.length === 0) {
+            log(`skip ${pkg.packageName}: no models`);
+            continue;
+        }
+        log(`include ${pkg.packageName}@${pkg.version}${excluded ? ' (declares recipes)' : ''}`);
+        extracted.push(pkg);
+    }
+    extracted.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return {
+        schema: 1,
+        registry,
+        packages: withEffectiveDemo(resolveDependencies(extracted)),
+    };
+}
+function renderable(catalog, log) {
+    return {
+        ...catalog,
+        packages: dropUnrenderableRecipes(catalog.packages, log),
+    };
+}
+/**
+ * Drop the recipes a browser mock-up cannot show: one that lists a model no
+ * catalog package declares, or whose menu opens a model with no screen (not
+ * exposed), or that needs a recipe dropped for either reason. A package left
+ * with no recipe and no exposed model has nothing to pick and goes too. Every
+ * drop is logged; the reasons are the manifest's, so the fix is upstream.
+ */
+export function dropUnrenderableRecipes(packages, log = () => { }) {
+    const models = new Map();
+    for (const pkg of packages) {
+        for (const model of pkg.models)
+            models.set(model.id, model.exposed);
+    }
+    const dropped = new Set();
+    const why = (recipe) => {
+        for (const id of recipe.models) {
+            if (!models.has(id))
+                return `lists ${id}, which no package declares`;
+        }
+        for (const entry of recipe.nav) {
+            if (models.get(entry.model) === false) {
+                return `opens ${entry.model} from the menu, which is not exposed`;
+            }
+        }
+        for (const id of recipe.requires) {
+            if (dropped.has(id))
+                return `needs ${id}`;
+        }
+        for (const group of recipe.requiresAny ?? []) {
+            if (group.length > 0 && group.every((id) => dropped.has(id))) {
+                return `needs one of ${group.join(', ')}`;
+            }
+        }
+        return undefined;
+    };
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const pkg of packages) {
+            for (const recipe of pkg.recipes ?? []) {
+                if (dropped.has(recipe.id))
+                    continue;
+                const reason = why(recipe);
+                if (!reason)
+                    continue;
+                dropped.add(recipe.id);
+                changed = true;
+                log(`drop recipe ${recipe.id}: ${reason}`);
+            }
+        }
+    }
+    if (dropped.size === 0)
+        return [...packages];
+    const out = [];
+    for (const pkg of packages) {
+        const all = pkg.recipes ?? [];
+        const kept = all.filter((r) => !dropped.has(r.id));
+        if (kept.length < all.length &&
+            kept.length === 0 &&
+            !pkg.models.some((m) => m.exposed)) {
+            log(`skip ${pkg.packageName}: nothing left to pick`);
+            continue;
+        }
+        const { recipes: _recipes, ...rest } = pkg;
+        out.push(kept.length > 0 ? { ...rest, recipes: kept } : rest);
+    }
+    return out;
+}
+/**
+ * Build the catalog from the registry (discover every `smrt-*` package), or,
+ * when `source` is set, from a local smrt checkout's built manifests.
+ */
+export async function buildCatalog(options) {
+    const log = options.log ?? (() => { });
+    if (options.source) {
+        const raws = await readLocalPackages(options.source);
+        return renderable(assembleCatalog(raws, `file://${options.source}`, log), log);
+    }
+    const names = await discoverPackageNames(options.registry);
+    // Excluded packages are fetched too: one that declares recipes stays, and
+    // only its manifest says (see `assembleCatalog`).
+    const raws = [];
+    for (let i = 0; i < names.length; i += 6) {
+        const batch = await Promise.all(names.slice(i, i + 6).map((name) => fetchPackage(options.registry, name)));
+        for (const raw of batch)
+            if (raw)
+                raws.push(raw);
+    }
+    return renderable(assembleCatalog(raws, options.registry, log), log);
+}

package/dist/catalog/generate/exclusions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Packages that are s-m-r-t infrastructure, not domain modules a visitor would
+ * "pick": they publish a `manifest.json` (or none) but carry no business models
+ * worth mocking up. Everything else that exports `./manifest.json` and declares
+ * at least one model is a catalog package, discovered from the registry.
+ *
+ * A listed package that declares recipes is NOT excluded: its recipes are
+ * features a visitor can pick (`chat.assistant`, `fields.form-customization`),
+ * so `assembleCatalog` keeps it and the exclusion applies only to a package
+ * with none.
+ *
+ * Packages without a `./manifest.json` export (cli, app-runtime, svelte, ui,
+ * vitest, ...) never need listing; they are skipped by discovery itself.
+ * Short names, without the `smrt-` prefix.
+ */
+export declare const EXCLUDED_PACKAGES: Readonly<Record<string, string>>;
+export declare const PACKAGE_SCOPE = "@happyvertical/";
+export declare const PACKAGE_PREFIX = "@happyvertical/smrt-";

package/dist/catalog/generate/exclusions.js

@@ -0,0 +1,33 @@
+/**
+ * Packages that are s-m-r-t infrastructure, not domain modules a visitor would
+ * "pick": they publish a `manifest.json` (or none) but carry no business models
+ * worth mocking up. Everything else that exports `./manifest.json` and declares
+ * at least one model is a catalog package, discovered from the registry.
+ *
+ * A listed package that declares recipes is NOT excluded: its recipes are
+ * features a visitor can pick (`chat.assistant`, `fields.form-customization`),
+ * so `assembleCatalog` keeps it and the exclusion applies only to a package
+ * with none.
+ *
+ * Packages without a `./manifest.json` export (cli, app-runtime, svelte, ui,
+ * vitest, ...) never need listing; they are skipped by discovery itself.
+ * Short names, without the `smrt-` prefix.
+ */
+export const EXCLUDED_PACKAGES = {
+    affiliates: 'deprecated compatibility shim over smrt-sales; no models',
+    agents: 'agent framework (infrastructure)',
+    chat: 'chat runtime and conversation infrastructure',
+    core: 'the framework itself',
+    features: 'feature-flag infrastructure',
+    fields: 'field-policy infrastructure',
+    gnode: 'federation library; no models',
+    jobs: 'background-job infrastructure',
+    languages: 'string-table infrastructure',
+    personas: 'agent-persona infrastructure',
+    playbooks: 'agent-playbook infrastructure',
+    prompts: 'prompt-registry infrastructure',
+    secrets: 'secret storage infrastructure',
+    tenancy: 'multi-tenancy infrastructure',
+};
+export const PACKAGE_SCOPE = '@happyvertical/';
+export const PACKAGE_PREFIX = `${PACKAGE_SCOPE}smrt-`;

package/dist/catalog/generate/extract.d.ts

@@ -0,0 +1,90 @@
+import type { CatalogPackage } from '../types.ts';
+/** The subset of a s-m-r-t `manifest.json` the catalog reads. */
+export interface RawManifest {
+    packageName: string;
+    smrtDependencies?: string[];
+    objects: Record<string, RawObject>;
+    /** Recipes the package declares (`SmrtRecipe`, smrt#3590/#3604). */
+    recipes?: unknown;
+    /** Whether the package builds for a browser (smrt#3709). */
+    browser?: unknown;
+}
+interface RawParameter {
+    name: string;
+    type: string;
+    optional?: boolean;
+}
+interface RawMethod {
+    name: string;
+    async?: boolean;
+    parameters?: RawParameter[];
+    returnType?: string;
+    isStatic?: boolean;
+    isPublic?: boolean;
+}
+interface RawField {
+    type: string;
+    required?: boolean;
+    description?: string;
+    default?: unknown;
+    related?: string;
+    enum?: unknown;
+    _meta?: {
+        ui?: unknown;
+        description?: unknown;
+        [key: string]: unknown;
+    };
+}
+interface RawObject {
+    className: string;
+    qualifiedName: string;
+    collection: string;
+    extends?: string;
+    extendsTypeArg?: string;
+    /** The class's doc description (emitted by newer scanners only). */
+    description?: string;
+    /** The own field that labels a record in pickers (smrt#3611). */
+    displayLabelField?: string;
+    /** Models and their collections may both carry the generated table schema. */
+    schema?: {
+        tableName?: string;
+    };
+    fields: Record<string, RawField>;
+    methods: Record<string, RawMethod>;
+    decoratorConfig: Record<string, unknown>;
+}
+/** The subset of a `smrt-knowledge.json` the catalog reads. */
+export interface RawKnowledge {
+    surfaces?: RawSurface[];
+    /** Recipes the package declares; also in the manifest. */
+    recipes?: unknown;
+    /** Browser capability; also in the manifest. */
+    browser?: unknown;
+}
+interface RawSurface {
+    kind: 'api' | 'mcp' | 'cli' | (string & {});
+    name: string;
+    operation: string;
+    objectName: string;
+    path?: string;
+    method?: string;
+}
+export interface RawPackage {
+    packageName: string;
+    version: string;
+    description: string;
+    manifest: RawManifest;
+    knowledge: RawKnowledge | null;
+}
+/** `@happyvertical/smrt-products` -> `products`. */
+export declare function packageId(packageName: string): string;
+/** Turn one package's raw manifest and knowledge into a catalog entry. */
+export declare function extractPackage(raw: RawPackage): CatalogPackage;
+/**
+ * Resolve each package's dependencies: the other catalog packages named in its
+ * manifest's `smrtDependencies` or pointed at by its models' foreign keys and
+ * cross-package references. Packages outside the catalog (excluded
+ * infrastructure) are not dependencies.
+ */
+export declare function resolveDependencies(packages: CatalogPackage[]): CatalogPackage[];
+export {};

package/dist/catalog/generate/extract.js

@@ -0,0 +1,326 @@
+import { PACKAGE_PREFIX } from "./exclusions.js";
+import { extractBrowser, extractRecipeMetadata } from "./recipe-metadata.js";
+/** Fields the framework manages; shown in the catalog, hidden from forms. */
+const SYSTEM_FIELDS = new Set([
+    'id',
+    'created_at',
+    'updated_at',
+    'createdAt',
+    'updatedAt',
+    'tenantId',
+]);
+/** Field types that hold other rows, not a value a form can edit. */
+const NON_VALUE_TYPES = new Set(['oneToMany', 'meta']);
+const CRUD_VERBS = ['list', 'get', 'create', 'update', 'delete'];
+const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+/** `@happyvertical/smrt-products` -> `products`. */
+export function packageId(packageName) {
+    return packageName.startsWith(PACKAGE_PREFIX)
+        ? packageName.slice(PACKAGE_PREFIX.length)
+        : packageName;
+}
+function primitiveDefault(value) {
+    return typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value === null
+        ? value
+        : undefined;
+}
+const WIDGETS = new Set([
+    'textarea',
+    'currency',
+    'email',
+    'url',
+    'phone',
+]);
+/** Keep only the known `ui` keys, with their expected primitive types. */
+function extractUi(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const raw = value;
+    const ui = {
+        ...(typeof raw.basic === 'boolean' ? { basic: raw.basic } : {}),
+        ...(typeof raw.group === 'string' ? { group: raw.group } : {}),
+        ...(typeof raw.order === 'number' && Number.isFinite(raw.order)
+            ? { order: raw.order }
+            : {}),
+        ...(typeof raw.locked === 'boolean' ? { locked: raw.locked } : {}),
+        ...(typeof raw.widget === 'string' && WIDGETS.has(raw.widget)
+            ? { widget: raw.widget }
+            : {}),
+    };
+    return Object.keys(ui).length > 0 ? ui : undefined;
+}
+function extractEnum(value) {
+    return Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((v) => typeof v === 'string')
+        ? value
+        : undefined;
+}
+function extractFields(raw) {
+    const fields = [];
+    for (const [name, field] of Object.entries(raw.fields)) {
+        if (NON_VALUE_TYPES.has(field.type))
+            continue;
+        const entry = {
+            name,
+            type: field.type,
+            required: field.required === true,
+        };
+        const fallback = primitiveDefault(field.default);
+        if (fallback !== undefined)
+            entry.default = fallback;
+        if (field.related)
+            entry.related = field.related;
+        const values = extractEnum(field.enum);
+        if (values)
+            entry.enum = values;
+        const ui = extractUi(field._meta?.ui);
+        if (ui)
+            entry.ui = ui;
+        const described = field.description ?? field._meta?.description;
+        if (typeof described === 'string' && described.trim()) {
+            entry.description = described.trim();
+        }
+        if (SYSTEM_FIELDS.has(name))
+            entry.system = true;
+        fields.push(entry);
+    }
+    return fields;
+}
+/**
+ * The surfaces a model gets when the knowledge artifact is absent: derived
+ * from `decoratorConfig` the way the generators do (an omitted `api`/`mcp`/
+ * `cli` key means full CRUD; `false` means none; `include` narrows it).
+ */
+function derivedVerbs(config) {
+    if (config === false)
+        return [];
+    if (config && typeof config === 'object') {
+        const { include, exclude } = config;
+        const base = include ?? [...CRUD_VERBS];
+        return base.filter((verb) => !exclude?.includes(verb));
+    }
+    return [...CRUD_VERBS];
+}
+const REST_VERB = {
+    list: { method: 'GET', path: '' },
+    get: { method: 'GET', path: '/[id]' },
+    create: { method: 'POST', path: '' },
+    update: { method: 'PATCH', path: '/[id]' },
+    delete: { method: 'DELETE', path: '/[id]' },
+};
+function derivedSurfaces(raw) {
+    const lower = raw.className.toLowerCase();
+    const surfaces = [];
+    const add = (kind, config) => {
+        for (const verb of derivedVerbs(config)) {
+            const route = REST_VERB[verb];
+            if (kind === 'api' && !route)
+                continue;
+            surfaces.push({
+                kind,
+                name: kind === 'api' ? `${raw.collection}.${verb}` : `${lower}_${verb}`,
+                operation: verb,
+                objectName: raw.qualifiedName,
+                ...(kind === 'api' && route
+                    ? { method: route.method, path: `/${raw.collection}${route.path}` }
+                    : {}),
+            });
+        }
+    };
+    add('api', raw.decoratorConfig.api);
+    add('mcp', raw.decoratorConfig.mcp);
+    add('cli', raw.decoratorConfig.cli);
+    return surfaces;
+}
+/** Collection classes carry the custom actions; they belong to their model. */
+function ownerName(raw) {
+    return raw.extendsTypeArg ?? raw.className.replace(/Collection$/, '');
+}
+function isModel(raw, objects) {
+    // A derived collection may inherit a table schema without carrying its own
+    // type argument. Resolve ancestry before accepting schema/field evidence.
+    const seen = new Set();
+    let ancestor = raw;
+    while (ancestor && !seen.has(ancestor)) {
+        seen.add(ancestor);
+        if (ancestor.extends === 'SmrtCollection' ||
+            ancestor.extendsTypeArg !== undefined) {
+            return false;
+        }
+        if (ancestor.extends === 'SmrtObject')
+            return true;
+        if (!ancestor.extends)
+            break;
+        const namespace = ancestor.qualifiedName.slice(0, ancestor.qualifiedName.lastIndexOf(':'));
+        const parent = ancestor.extends.includes(':')
+            ? ancestor.extends
+            : `${namespace}:${ancestor.extends}`;
+        ancestor = objects.get(parent);
+    }
+    return (!!raw.schema?.tableName ||
+        Object.values(raw.fields).some((f) => !NON_VALUE_TYPES.has(f.type)));
+}
+function qualify(related, packageName, models) {
+    if (related.includes(':'))
+        return related;
+    const local = `${packageName}:${related}`;
+    return models.has(local) ? local : related;
+}
+const RECIPE_METADATA_KEYS = [
+    'surfaces',
+    'providers',
+    'runtime',
+    'demoSeed',
+    'demo',
+];
+/**
+ * The recipes a package declares, in declaration order, from its knowledge
+ * artifact (else its manifest). Dropped when they are not an array of
+ * objects with a string `id`. `className` is a source detail, not catalog data.
+ * The non-model parts (surfaces, providers, runtime, demo seed, demo) are
+ * validated by `recipe-metadata.ts` and carried as authored.
+ */
+function extractRecipes(raw) {
+    const found = raw.knowledge?.recipes ?? raw.manifest.recipes;
+    if (!Array.isArray(found))
+        return [];
+    return found
+        .filter((r) => !!r &&
+        typeof r === 'object' &&
+        typeof r.id === 'string')
+        .map((entry) => {
+        const { className: _className, ...recipe } = entry;
+        for (const key of RECIPE_METADATA_KEYS)
+            delete recipe[key];
+        return {
+            ...recipe,
+            ...extractRecipeMetadata(entry),
+        };
+    });
+}
+/** Turn one package's raw manifest and knowledge into a catalog entry. */
+export function extractPackage(raw) {
+    const { manifest, knowledge, packageName } = raw;
+    const recipes = extractRecipes(raw);
+    const browser = extractBrowser(knowledge?.browser ?? manifest.browser);
+    const objects = Object.values(manifest.objects);
+    const objectMap = new Map(objects.map((o) => [o.qualifiedName, o]));
+    const rawModels = objects.filter((o) => isModel(o, objectMap));
+    const modelMap = new Map(rawModels.map((m) => [m.qualifiedName, m]));
+    const collections = objects.filter((o) => !modelMap.has(o.qualifiedName));
+    const knowledgeSurfaces = knowledge?.surfaces ?? null;
+    const models = rawModels.map((model) => {
+        const owned = [
+            model,
+            ...collections.filter((c) => ownerName(c) === model.className),
+        ];
+        const ownedNames = new Set(owned.map((o) => o.qualifiedName));
+        const surfaces = knowledgeSurfaces
+            ? knowledgeSurfaces.filter((s) => ownedNames.has(s.objectName))
+            : derivedSurfaces(model);
+        const seen = new Set();
+        const unique = surfaces.filter((s) => {
+            const key = `${s.kind}:${s.name}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        const rest = unique
+            .filter((s) => s.kind === 'api' && s.path && s.method)
+            .map((s) => ({ method: s.method, path: s.path }));
+        const operations = (kind) => unique
+            .filter((s) => s.kind === kind)
+            .map((s) => ({ operation: s.operation, name: s.name }))
+            .sort(byName);
+        const mcp = operations('mcp');
+        const cli = operations('cli');
+        const mcpOps = new Set(mcp.map((t) => t.operation));
+        const methods = owned
+            .flatMap((o) => Object.values(o.methods))
+            .filter((m) => m.isPublic !== false && !m.isStatic)
+            .filter((m, i, all) => all.findIndex((x) => x.name === m.name) === i)
+            .map((m) => ({
+            name: m.name,
+            async: m.async === true,
+            parameters: (m.parameters ?? []).map((p) => `${p.name}${p.optional ? '?' : ''}: ${p.type}`),
+            returnType: m.returnType ?? 'unknown',
+            aiCallable: mcpOps.has(m.name),
+        }))
+            .sort(byName);
+        const fields = extractFields(model);
+        const references = [
+            ...new Set(fields
+                .filter((f) => f.related && ['foreignKey', 'crossPackageRef'].includes(f.type))
+                .map((f) => qualify(f.related, packageName, modelMap))),
+        ].sort();
+        for (const field of fields) {
+            if (field.related) {
+                field.related = qualify(field.related, packageName, modelMap);
+            }
+        }
+        return {
+            id: model.qualifiedName,
+            name: model.className,
+            collection: model.collection,
+            ...(model.extends && modelMap.has(`${packageName}:${model.extends}`)
+                ? { extends: `${packageName}:${model.extends}` }
+                : {}),
+            ...(model.description?.trim()
+                ? { description: model.description.trim() }
+                : {}),
+            ...(model.displayLabelField &&
+                fields.some((f) => f.name === model.displayLabelField)
+                ? { display: { label: model.displayLabelField } }
+                : {}),
+            fields,
+            rest,
+            mcp,
+            cli,
+            methods,
+            references,
+            exposed: rest.length + mcp.length + cli.length > 0,
+        };
+    });
+    models.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return {
+        id: packageId(packageName),
+        packageName,
+        version: raw.version,
+        description: raw.description,
+        models,
+        dependencies: (manifest.smrtDependencies ?? []).map(packageId).sort(),
+        surfaceSource: knowledgeSurfaces ? 'knowledge' : 'manifest',
+        ...(browser ? { browser } : {}),
+        ...(recipes.length > 0 ? { recipes } : {}),
+    };
+}
+/**
+ * Resolve each package's dependencies: the other catalog packages named in its
+ * manifest's `smrtDependencies` or pointed at by its models' foreign keys and
+ * cross-package references. Packages outside the catalog (excluded
+ * infrastructure) are not dependencies.
+ */
+export function resolveDependencies(packages) {
+    const ids = new Set(packages.map((p) => p.id));
+    return packages.map((pkg) => {
+        const deps = new Set(pkg.dependencies.filter((id) => ids.has(id)));
+        for (const model of pkg.models) {
+            for (const ref of model.references) {
+                const colon = ref.indexOf(':');
+                if (colon < 0)
+                    continue;
+                const id = packageId(ref.slice(0, colon));
+                if (ids.has(id))
+                    deps.add(id);
+            }
+        }
+        deps.delete(pkg.id);
+        return { ...pkg, dependencies: [...deps].sort() };
+    });
+}

package/dist/catalog/generate/local.d.ts

@@ -0,0 +1,8 @@
+import type { RawPackage } from './extract.ts';
+/**
+ * Read every `@happyvertical/smrt-*` package of a local smrt checkout that has
+ * been built (the file its `./manifest` export names, usually
+ * `dist/manifest.json`, plus the `smrt-knowledge.json` beside it). Packages that are not built are skipped.
+ * This is the opt-in `CATALOG_SOURCE` path for previewing unreleased manifests.
+ */
+export declare function readLocalPackages(checkout: string): Promise<RawPackage[]>;

package/dist/catalog/generate/local.js

@@ -0,0 +1,45 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { PACKAGE_PREFIX } from "./exclusions.js";
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** The manifest path a package publishes as `./manifest`, else `dist/manifest.json`. */
+function manifestPath(pkg) {
+    const target = pkg.exports?.['./manifest'];
+    return typeof target === 'string' ? target : './dist/manifest.json';
+}
+/**
+ * Read every `@happyvertical/smrt-*` package of a local smrt checkout that has
+ * been built (the file its `./manifest` export names, usually
+ * `dist/manifest.json`, plus the `smrt-knowledge.json` beside it). Packages that are not built are skipped.
+ * This is the opt-in `CATALOG_SOURCE` path for previewing unreleased manifests.
+ */
+export async function readLocalPackages(checkout) {
+    const packagesDir = join(resolve(checkout), 'packages');
+    const dirs = (await readdir(packagesDir)).sort();
+    const raws = [];
+    for (const dir of dirs) {
+        const pkgDir = join(packagesDir, dir);
+        const pkg = await readJson(join(pkgDir, 'package.json'));
+        if (!pkg?.name?.startsWith(PACKAGE_PREFIX))
+            continue;
+        const manifestFile = join(pkgDir, manifestPath(pkg));
+        const manifest = await readJson(manifestFile);
+        if (!manifest)
+            continue;
+        raws.push({
+            packageName: pkg.name,
+            version: pkg.version ?? '0.0.0',
+            description: pkg.description ?? '',
+            manifest,
+            knowledge: await readJson(join(dirname(manifestFile), 'smrt-knowledge.json')),
+        });
+    }
+    return raws;
+}