@synergenius/flow-weaver 0.2.0

package/dist/marketplace/index.js

@@ -0,0 +1,10 @@
+/**
+ * @module marketplace
+ *
+ * Flow Weaver Marketplace — discover, install, and publish reusable
+ * node types, workflows, and patterns via npm.
+ */
+export { generateManifest, writeManifest, readManifest, } from './manifest.js';
+export { validatePackage } from './validator.js';
+export { searchPackages, listInstalledPackages, getInstalledPackageManifest, } from './registry.js';
+//# sourceMappingURL=index.js.map

package/dist/marketplace/manifest.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Manifest generation — converts parsed ASTs into a flowweaver.manifest.json file.
+ *
+ * The manifest mirrors AST types so the editor can consume it directly
+ * without re-parsing source files.
+ */
+import type { TMarketplaceManifest } from './types.js';
+export interface GenerateManifestOptions {
+    /** Root directory of the marketplace package */
+    directory: string;
+    /** Source directory to scan (default: "src") */
+    srcDir?: string;
+    /** Dist directory for compiled output paths (default: "dist") */
+    distDir?: string;
+}
+export interface GenerateManifestResult {
+    manifest: TMarketplaceManifest;
+    /** Source files that were parsed */
+    parsedFiles: string[];
+    /** Parse errors encountered */
+    errors: string[];
+}
+/**
+ * Generate a marketplace manifest by parsing all annotated source files
+ * in the package directory.
+ */
+export declare function generateManifest(options: GenerateManifestOptions): Promise<GenerateManifestResult>;
+/** Write manifest JSON to disk. */
+export declare function writeManifest(directory: string, manifest: TMarketplaceManifest): string;
+/** Read manifest JSON from disk. */
+export declare function readManifest(directory: string): TMarketplaceManifest | null;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/marketplace/manifest.js

@@ -0,0 +1,176 @@
+/**
+ * Manifest generation — converts parsed ASTs into a flowweaver.manifest.json file.
+ *
+ * The manifest mirrors AST types so the editor can consume it directly
+ * without re-parsing source files.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import { AnnotationParser } from '../parser.js';
+// ── Port mapping ─────────────────────────────────────────────────────────────
+function toManifestPort(port) {
+    return {
+        dataType: port.dataType,
+        ...(port.description && { description: port.description }),
+        ...(port.optional && { optional: true }),
+    };
+}
+function toManifestPortFromPattern(port) {
+    return {
+        dataType: port.dataType ?? 'ANY',
+        ...(port.description && { description: port.description }),
+    };
+}
+function toManifestPorts(ports) {
+    const result = {};
+    for (const [name, def] of Object.entries(ports)) {
+        result[name] = toManifestPort(def);
+    }
+    return result;
+}
+// ── AST → Manifest mapping ──────────────────────────────────────────────────
+function nodeTypeToManifest(nt, relativeFile) {
+    return {
+        name: nt.name,
+        ...(nt.description && { description: nt.description }),
+        file: relativeFile,
+        functionName: nt.functionName,
+        isAsync: nt.isAsync,
+        inputs: toManifestPorts(nt.inputs),
+        outputs: toManifestPorts(nt.outputs),
+        ...(nt.visuals && {
+            visuals: {
+                ...(nt.visuals.color && { color: nt.visuals.color }),
+                ...(nt.visuals.icon && { icon: nt.visuals.icon }),
+                ...(nt.visuals.tags && { tags: nt.visuals.tags }),
+            },
+        }),
+    };
+}
+function workflowToManifest(wf, relativeFile) {
+    return {
+        name: wf.name,
+        ...(wf.description && { description: wf.description }),
+        file: relativeFile,
+        functionName: wf.functionName,
+        startPorts: toManifestPorts(wf.startPorts),
+        exitPorts: toManifestPorts(wf.exitPorts),
+        nodeCount: wf.instances.length,
+        connectionCount: wf.connections.length,
+    };
+}
+function patternToManifest(pat, relativeFile) {
+    const inputPorts = {};
+    for (const [name, def] of Object.entries(pat.inputPorts)) {
+        inputPorts[name] = toManifestPortFromPattern(def);
+    }
+    const outputPorts = {};
+    for (const [name, def] of Object.entries(pat.outputPorts)) {
+        outputPorts[name] = toManifestPortFromPattern(def);
+    }
+    return {
+        name: pat.name,
+        ...(pat.description && { description: pat.description }),
+        file: relativeFile,
+        inputPorts,
+        outputPorts,
+        nodeCount: pat.instances.length,
+    };
+}
+/**
+ * Generate a marketplace manifest by parsing all annotated source files
+ * in the package directory.
+ */
+export async function generateManifest(options) {
+    const { directory, srcDir = 'src', distDir = 'dist' } = options;
+    // Read package.json
+    const pkgPath = path.join(directory, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        return {
+            manifest: emptyManifest('unknown', '0.0.0'),
+            parsedFiles: [],
+            errors: ['package.json not found'],
+        };
+    }
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const srcRoot = path.join(directory, srcDir);
+    // Find all TypeScript files in src/
+    const pattern = path.join(srcRoot, '**/*.ts').replace(/\\/g, '/');
+    const files = await glob(pattern, { absolute: true });
+    const tsFiles = files.filter((f) => !f.endsWith('.d.ts') && !f.includes('node_modules'));
+    const parser = new AnnotationParser();
+    const allNodeTypes = [];
+    const allWorkflows = [];
+    const allPatterns = [];
+    const errors = [];
+    const parsedFiles = [];
+    for (const file of tsFiles) {
+        try {
+            const result = parser.parse(file);
+            parsedFiles.push(file);
+            // Map source paths to dist paths: src/foo/bar.ts → dist/foo/bar.js
+            const relFromSrc = path.relative(srcRoot, file);
+            const distRelative = path.join(distDir, relFromSrc.replace(/\.ts$/, '.js'));
+            // Collect standalone node types (not embedded in workflows)
+            for (const nt of result.nodeTypes) {
+                allNodeTypes.push(nodeTypeToManifest(nt, distRelative));
+            }
+            // Collect workflows
+            for (const wf of result.workflows) {
+                allWorkflows.push(workflowToManifest(wf, distRelative));
+            }
+            // Collect patterns
+            for (const pat of result.patterns) {
+                allPatterns.push(patternToManifest(pat, distRelative));
+            }
+            if (result.errors.length > 0) {
+                errors.push(...result.errors.map((e) => `${file}: ${e}`));
+            }
+        }
+        catch (err) {
+            errors.push(`Failed to parse ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const manifest = {
+        manifestVersion: 1,
+        name: pkg.name ?? 'unknown',
+        version: pkg.version ?? '0.0.0',
+        ...(pkg.description && { description: pkg.description }),
+        ...(pkg.flowWeaver?.engineVersion && { engineVersion: pkg.flowWeaver.engineVersion }),
+        ...(pkg.flowWeaver?.categories && { categories: pkg.flowWeaver.categories }),
+        nodeTypes: allNodeTypes,
+        workflows: allWorkflows,
+        patterns: allPatterns,
+        ...(Object.keys(pkg.dependencies ?? {}).length > 0 && {
+            dependencies: {
+                npm: pkg.dependencies,
+            },
+        }),
+    };
+    return { manifest, parsedFiles, errors };
+}
+/** Write manifest JSON to disk. */
+export function writeManifest(directory, manifest) {
+    const outPath = path.join(directory, 'flowweaver.manifest.json');
+    fs.writeFileSync(outPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+    return outPath;
+}
+/** Read manifest JSON from disk. */
+export function readManifest(directory) {
+    const manifestPath = path.join(directory, 'flowweaver.manifest.json');
+    if (!fs.existsSync(manifestPath))
+        return null;
+    return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+}
+function emptyManifest(name, version) {
+    return {
+        manifestVersion: 1,
+        name,
+        version,
+        nodeTypes: [],
+        workflows: [],
+        patterns: [],
+    };
+}
+//# sourceMappingURL=manifest.js.map

package/dist/marketplace/registry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Registry integration — npm search API + local package scanning.
+ *
+ * Uses the npm registry search endpoint filtered by the
+ * `flowweaver-marketplace-pack` keyword for discovery, and scans
+ * `node_modules/` for locally installed packages.
+ */
+import type { TMarketplaceManifest, TMarketplacePackageInfo, TInstalledPackage } from './types.js';
+export interface SearchOptions {
+    /** Search query text */
+    query?: string;
+    /** Maximum number of results (default: 20) */
+    limit?: number;
+    /** Custom registry search URL (default: public npm registry). Supports private registries like Verdaccio, GitHub Packages, etc. */
+    registryUrl?: string;
+}
+/**
+ * Search the npm registry for marketplace packages.
+ */
+export declare function searchPackages(options?: SearchOptions): Promise<TMarketplacePackageInfo[]>;
+/**
+ * Scan node_modules for installed marketplace packages by looking for
+ * `flowweaver.manifest.json` files in matching package directories.
+ */
+export declare function listInstalledPackages(projectDir: string): Promise<TInstalledPackage[]>;
+/**
+ * Read the manifest for a specific installed package.
+ */
+export declare function getInstalledPackageManifest(projectDir: string, packageName: string): TMarketplaceManifest | null;
+//# sourceMappingURL=registry.d.ts.map

package/dist/marketplace/registry.js

@@ -0,0 +1,100 @@
+/**
+ * Registry integration — npm search API + local package scanning.
+ *
+ * Uses the npm registry search endpoint filtered by the
+ * `flowweaver-marketplace-pack` keyword for discovery, and scans
+ * `node_modules/` for locally installed packages.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+const MARKETPLACE_KEYWORD = 'flowweaver-marketplace-pack';
+const NPM_SEARCH_URL = 'https://registry.npmjs.org/-/v1/search';
+const PACK_NAME_RE = /^(@[^/]+\/)?flowweaver-pack-.+$/;
+/**
+ * Search the npm registry for marketplace packages.
+ */
+export async function searchPackages(options = {}) {
+    const { query, limit = 20, registryUrl } = options;
+    // Build search query: always filter by marketplace keyword
+    const textParts = [
+        `keywords:${MARKETPLACE_KEYWORD}`,
+        ...(query ? [query] : []),
+    ];
+    const url = new URL(registryUrl ?? NPM_SEARCH_URL);
+    url.searchParams.set('text', textParts.join(' '));
+    url.searchParams.set('size', String(limit));
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        throw new Error(`npm search failed: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.objects
+        .filter((obj) => PACK_NAME_RE.test(obj.package.name))
+        .map((obj) => ({
+        name: obj.package.name,
+        version: obj.package.version,
+        description: obj.package.description,
+        keywords: obj.package.keywords,
+        publisher: obj.package.publisher?.username,
+        official: obj.package.name.startsWith('@synergenius/'),
+    }));
+}
+// ── Local scanning ───────────────────────────────────────────────────────────
+/**
+ * Scan node_modules for installed marketplace packages by looking for
+ * `flowweaver.manifest.json` files in matching package directories.
+ */
+export async function listInstalledPackages(projectDir) {
+    const nodeModules = path.join(projectDir, 'node_modules');
+    if (!fs.existsSync(nodeModules))
+        return [];
+    // Look for flowweaver-pack-* and @*/flowweaver-pack-* directories
+    const patterns = [
+        path.join(nodeModules, 'flowweaver-pack-*', 'flowweaver.manifest.json'),
+        path.join(nodeModules, '@*', 'flowweaver-pack-*', 'flowweaver.manifest.json'),
+    ];
+    const results = [];
+    for (const pattern of patterns) {
+        const manifestPaths = await glob(pattern.replace(/\\/g, '/'), { absolute: true });
+        for (const manifestPath of manifestPaths) {
+            try {
+                const pkgDir = path.dirname(manifestPath);
+                const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                // Also read package.json for accurate version
+                const pkgJsonPath = path.join(pkgDir, 'package.json');
+                let version = manifest.version;
+                if (fs.existsSync(pkgJsonPath)) {
+                    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                    version = pkg.version ?? manifest.version;
+                }
+                results.push({
+                    name: manifest.name,
+                    version,
+                    manifest,
+                    path: pkgDir,
+                });
+            }
+            catch {
+                // Skip malformed manifests
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Read the manifest for a specific installed package.
+ */
+export function getInstalledPackageManifest(projectDir, packageName) {
+    const packageDir = path.join(projectDir, 'node_modules', packageName);
+    const manifestPath = path.join(packageDir, 'flowweaver.manifest.json');
+    if (!fs.existsSync(manifestPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/marketplace/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Marketplace types for Flow Weaver package distribution.
+ *
+ * Packages follow the naming convention `flowweaver-pack-*` and use
+ * npm as the distribution backbone. The manifest is auto-generated
+ * from source annotations via the parser.
+ */
+import type { TDataType } from '../ast/types.js';
+/** Auto-generated manifest describing a marketplace package's contents. */
+export type TMarketplaceManifest = {
+    /** Manifest schema version (currently 1) */
+    manifestVersion: 1;
+    /** npm package name */
+    name: string;
+    /** Semver version */
+    version: string;
+    /** Human-readable description */
+    description?: string;
+    /** Minimum Flow Weaver engine version required */
+    engineVersion?: string;
+    /** Discovery categories */
+    categories?: string[];
+    /** Node types included in this package */
+    nodeTypes: TManifestNodeType[];
+    /** Workflows included in this package */
+    workflows: TManifestWorkflow[];
+    /** Patterns included in this package */
+    patterns: TManifestPattern[];
+    /** External dependency information */
+    dependencies?: {
+        /** Flow Weaver peer dependency constraints */
+        flowweaver?: Record<string, string>;
+        /** npm runtime dependencies */
+        npm?: Record<string, string>;
+    };
+};
+export type TManifestPort = {
+    dataType: TDataType;
+    description?: string;
+    optional?: boolean;
+};
+export type TManifestNodeType = {
+    /** Node type name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Relative path to compiled file */
+    file: string;
+    /** Function name in the source */
+    functionName: string;
+    /** Whether the function is async */
+    isAsync: boolean;
+    /** Input port definitions */
+    inputs: Record<string, TManifestPort>;
+    /** Output port definitions */
+    outputs: Record<string, TManifestPort>;
+    /** Visual customization */
+    visuals?: {
+        color?: string;
+        icon?: string;
+        tags?: Array<{
+            label: string;
+            color?: string;
+        }>;
+    };
+};
+export type TManifestWorkflow = {
+    /** Workflow name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Relative path to compiled file */
+    file: string;
+    /** Function name in the source */
+    functionName: string;
+    /** Start (input) ports */
+    startPorts: Record<string, TManifestPort>;
+    /** Exit (output) ports */
+    exitPorts: Record<string, TManifestPort>;
+    /** Number of node instances */
+    nodeCount: number;
+    /** Number of connections */
+    connectionCount: number;
+};
+export type TManifestPattern = {
+    /** Pattern name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Relative path to source file */
+    file: string;
+    /** Input ports (IN pseudo-node connections) */
+    inputPorts: Record<string, TManifestPort>;
+    /** Output ports (OUT pseudo-node connections) */
+    outputPorts: Record<string, TManifestPort>;
+    /** Number of internal nodes */
+    nodeCount: number;
+};
+export type TValidationSeverity = 'error' | 'warning';
+export type TValidationIssue = {
+    /** Unique rule identifier (e.g., PKG-001, UNIT-002) */
+    code: string;
+    /** error = must fix, warning = should fix */
+    severity: TValidationSeverity;
+    /** Human-readable description */
+    message: string;
+};
+export type TPackageValidationResult = {
+    /** Whether the package passed all error-level checks */
+    valid: boolean;
+    /** All issues found during validation */
+    issues: TValidationIssue[];
+};
+/** A marketplace package discovered via npm search or local scan. */
+export type TMarketplacePackageInfo = {
+    /** npm package name */
+    name: string;
+    /** Latest version */
+    version: string;
+    /** Package description */
+    description?: string;
+    /** npm weekly download count */
+    downloads?: number;
+    /** npm publisher username */
+    publisher?: string;
+    /** Package keywords */
+    keywords?: string[];
+    /** Whether this is an official @synergenius package */
+    official: boolean;
+};
+/** An installed marketplace package with its resolved manifest. */
+export type TInstalledPackage = {
+    /** npm package name */
+    name: string;
+    /** Installed version */
+    version: string;
+    /** Resolved manifest */
+    manifest: TMarketplaceManifest;
+    /** Absolute path to the package in node_modules */
+    path: string;
+};
+export type TMarketInitConfig = {
+    /** Package name (e.g., flowweaver-pack-openai) */
+    name: string;
+    /** Target directory */
+    directory: string;
+    /** Package description */
+    description?: string;
+    /** Author name */
+    author?: string;
+    /** Run npm install after scaffolding */
+    install: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/marketplace/types.js

@@ -0,0 +1,9 @@
+/**
+ * Marketplace types for Flow Weaver package distribution.
+ *
+ * Packages follow the naming convention `flowweaver-pack-*` and use
+ * npm as the distribution backbone. The manifest is auto-generated
+ * from source annotations via the parser.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/marketplace/validator.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Package validation — checks that a marketplace package meets
+ * all requirements before publishing.
+ */
+import type { TMarketplaceManifest } from './types.js';
+import type { TPackageValidationResult } from './types.js';
+/**
+ * Validate a marketplace package directory.
+ *
+ * Checks package.json fields, manifest contents, and individual workflow validity.
+ */
+export declare function validatePackage(directory: string, manifest: TMarketplaceManifest): Promise<TPackageValidationResult>;
+//# sourceMappingURL=validator.d.ts.map

package/dist/marketplace/validator.js

@@ -0,0 +1,131 @@
+/**
+ * Package validation — checks that a marketplace package meets
+ * all requirements before publishing.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseWorkflow, validateWorkflow } from '../api/index.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function issue(code, severity, message) {
+    return { code, severity, message };
+}
+const PACK_NAME_RE = /^(@[^/]+\/)?flowweaver-pack-.+$/;
+const MARKETPLACE_KEYWORD = 'flowweaver-marketplace-pack';
+// ── Package-level rules ──────────────────────────────────────────────────────
+function validatePackageJson(pkg, directory) {
+    const issues = [];
+    // PKG-005: Name must match flowweaver-pack-* or @*/flowweaver-pack-*
+    const name = pkg.name;
+    if (!name || !PACK_NAME_RE.test(name)) {
+        issues.push(issue('PKG-005', 'error', `Package name must match "flowweaver-pack-*" or "@<scope>/flowweaver-pack-*", got "${name ?? ''}"`));
+    }
+    // PKG-001: keywords must include flowweaver-marketplace-pack
+    const keywords = (pkg.keywords ?? []);
+    if (!keywords.includes(MARKETPLACE_KEYWORD)) {
+        issues.push(issue('PKG-001', 'error', `"keywords" must include "${MARKETPLACE_KEYWORD}"`));
+    }
+    // PKG-002: flowWeaver.engineVersion must be set
+    const fw = pkg.flowWeaver;
+    if (!fw?.engineVersion) {
+        issues.push(issue('PKG-002', 'error', '"flowWeaver.engineVersion" must be set in package.json'));
+    }
+    // PKG-003: peerDependencies must include @synergenius/flow-weaver
+    const peers = (pkg.peerDependencies ?? {});
+    if (!peers['@synergenius/flow-weaver']) {
+        issues.push(issue('PKG-003', 'error', '"peerDependencies" must include "@synergenius/flow-weaver"'));
+    }
+    // PKG-004: Must not be private
+    if (pkg.private === true) {
+        issues.push(issue('PKG-004', 'error', 'Package must not be "private: true"'));
+    }
+    // PKG-007: README.md should exist
+    if (!fs.existsSync(path.join(directory, 'README.md'))) {
+        issues.push(issue('PKG-007', 'warning', 'README.md should exist'));
+    }
+    return issues;
+}
+// ── Manifest-level rules ─────────────────────────────────────────────────────
+function validateManifestContents(manifest) {
+    const issues = [];
+    const totalUnits = manifest.nodeTypes.length + manifest.workflows.length + manifest.patterns.length;
+    // PKG-006: Must contain at least one unit
+    if (totalUnits === 0) {
+        issues.push(issue('PKG-006', 'error', 'Package must contain at least one node type, workflow, or pattern'));
+    }
+    // UNIT-002: Node type names must be unique within the package
+    const ntNames = new Set();
+    for (const nt of manifest.nodeTypes) {
+        if (ntNames.has(nt.name)) {
+            issues.push(issue('UNIT-002', 'error', `Duplicate node type name: "${nt.name}"`));
+        }
+        ntNames.add(nt.name);
+    }
+    // PKG-008: All node types should have descriptions
+    for (const nt of manifest.nodeTypes) {
+        if (!nt.description) {
+            issues.push(issue('PKG-008', 'warning', `Node type "${nt.name}" should have a description`));
+        }
+    }
+    // PKG-009: All node types should have visuals
+    for (const nt of manifest.nodeTypes) {
+        if (!nt.visuals || (!nt.visuals.color && !nt.visuals.icon && !nt.visuals.tags)) {
+            issues.push(issue('PKG-009', 'warning', `Node type "${nt.name}" should have visuals (color, icon, or tags)`));
+        }
+    }
+    // UNIT-003: Patterns must have at least one IN or OUT port
+    for (const pat of manifest.patterns) {
+        const inCount = Object.keys(pat.inputPorts).length;
+        const outCount = Object.keys(pat.outputPorts).length;
+        if (inCount === 0 && outCount === 0) {
+            issues.push(issue('UNIT-003', 'error', `Pattern "${pat.name}" must have at least one IN or OUT port`));
+        }
+    }
+    return issues;
+}
+// ── Workflow validation (UNIT-001) ───────────────────────────────────────────
+async function validateWorkflows(manifest, directory) {
+    const issues = [];
+    for (const wf of manifest.workflows) {
+        // Resolve source file from dist path back to src
+        const srcFile = path.join(directory, wf.file.replace(/^dist\//, 'src/').replace(/\.js$/, '.ts'));
+        if (!fs.existsSync(srcFile))
+            continue;
+        try {
+            const parseResult = await parseWorkflow(srcFile, { workflowName: wf.functionName });
+            if (parseResult.errors.length > 0)
+                continue; // Parse errors reported by pack command
+            const result = validateWorkflow(parseResult.ast);
+            if (result.errors.length > 0) {
+                issues.push(issue('UNIT-001', 'error', `Workflow "${wf.name}" has validation errors: ${result.errors.map((e) => e.message).join('; ')}`));
+            }
+        }
+        catch {
+            // If parsing fails entirely, the pack command will already have reported the error
+        }
+    }
+    return issues;
+}
+// ── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Validate a marketplace package directory.
+ *
+ * Checks package.json fields, manifest contents, and individual workflow validity.
+ */
+export async function validatePackage(directory, manifest) {
+    const pkgPath = path.join(directory, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        return {
+            valid: false,
+            issues: [issue('PKG-000', 'error', 'package.json not found')],
+        };
+    }
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const issues = [
+        ...validatePackageJson(pkg, directory),
+        ...validateManifestContents(manifest),
+        ...(await validateWorkflows(manifest, directory)),
+    ];
+    const valid = !issues.some((i) => i.severity === 'error');
+    return { valid, issues };
+}
+//# sourceMappingURL=validator.js.map

package/dist/mcp/auto-registration.d.ts

@@ -0,0 +1,3 @@
+import type { McpServerOptions, RegistrationDeps } from './types.js';
+export declare function offerClaudeRegistration(options: McpServerOptions, deps?: RegistrationDeps): Promise<void>;
+//# sourceMappingURL=auto-registration.d.ts.map