@ai-plugin-marketplace/core 0.1.0

package/dist/pipeline/init.js

@@ -0,0 +1,84 @@
+/**
+ * `runInit` — scaffold a thin consumer repo (the "template") that depends on
+ * `@ai-plugin-marketplace/cli` and holds plugin sources only (§3.2, §11).
+ *
+ * This is the filesystem-writing orchestrator behind the public `init` operation and the
+ * `aipm init [dir]` CLI surface. The generated file *contents* live in `init-template.ts`; this
+ * module is the I/O boundary: it resolves the toolkit version to pin, refuses to clobber a
+ * non-empty target, and writes the seed tree.
+ *
+ * **Version pinning (§9.1 lockstep release).** core and cli ship in lockstep, so the `cli` dev
+ * dependency is pinned to a caret of core's *own* version — read at runtime from this package's
+ * `package.json`, resolved relative to {@link import.meta.url} exactly as `load-config.ts` resolves
+ * the package entrypoint. Today that yields `^0.1.0-alpha.0`; once 0.1.0 ships, an `init` run from
+ * the published cli pins `^0.1.0`.
+ *
+ * @see docs/specs/architecture.md §3.2 (template repo contents)
+ * @see docs/specs/architecture.md §9.1 (lockstep release lines)
+ * @see docs/specs/architecture.md §11 (template→toolkit dependency contract)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildInitFiles } from './init-template.js';
+/**
+ * Read this package's `package.json#version`, resolved relative to this module's location.
+ *
+ * When bundled to `dist/pipeline/init.js` this resolves `<pkgRoot>/package.json`; when run from
+ * source as `src/pipeline/init.ts` it resolves the same file (both sit two levels up). Mirrors the
+ * version-resolution approach in `cli/src/run.ts` and the entrypoint resolution in
+ * `load-config.ts`.
+ */
+function coreVersion() {
+    const here = fileURLToPath(import.meta.url);
+    // here = <pkgRoot>/<src|dist>/pipeline/init.<ts|js>; package.json sits two levels up.
+    const pkgPath = path.join(path.dirname(here), '..', '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version;
+}
+/**
+ * True iff `dir` does not exist, or exists as an empty directory. A non-empty directory (or a
+ * path that exists as a non-directory) is treated as "would clobber".
+ */
+function isFreshTarget(dir) {
+    if (!fs.existsSync(dir))
+        return true;
+    const stat = fs.statSync(dir);
+    if (!stat.isDirectory())
+        return false;
+    return fs.readdirSync(dir).length === 0;
+}
+/**
+ * Scaffold a thin consumer repo at `targetDir` (§3.2).
+ *
+ * Writes `package.json` (with the `@ai-plugin-marketplace/cli` dev dependency pinned to a caret of
+ * the current toolkit version), `.gitignore`, `README.md`, both repo-root marketplace registries
+ * (`{ "plugins": [] }`), an empty `plugins/` (tracked via `.gitkeep`), and a CI workflow that runs
+ * `aipm build` then `aipm validate` (§10.5 freshness). The repo name defaults to
+ * `basename(targetDir)`; override it with `opts.name`.
+ *
+ * **Refuses to clobber.** If `targetDir` exists and is a non-empty directory (or exists as a
+ * non-directory), the function throws and writes nothing. Creating into a fresh or empty directory
+ * is fine.
+ *
+ * @param targetDir - Absolute or relative path to the directory to scaffold into.
+ * @param opts - Init options; `name` overrides the derived repo name.
+ * @throws {Error} When `targetDir` exists and is non-empty (or is not a directory).
+ */
+export async function runInit(targetDir, opts = {}) {
+    const resolved = path.resolve(targetDir);
+    if (!isFreshTarget(resolved)) {
+        throw new Error(`Refusing to scaffold into '${resolved}': the directory already exists and is not empty. ` +
+            'Choose a new path or an empty directory.');
+    }
+    const name = opts.name ?? path.basename(resolved);
+    const files = buildInitFiles(name, coreVersion());
+    fs.mkdirSync(resolved, { recursive: true });
+    for (const file of files) {
+        const full = path.join(resolved, file.path);
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, file.content, 'utf-8');
+    }
+    return Promise.resolve();
+}
+//# sourceMappingURL=init.js.map

package/dist/pipeline/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../src/pipeline/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD;;;;;;;GAOG;AACH,SAAS,WAAW;IAClB,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5C,sFAAsF;IACtF,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;IAC1E,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAwB,CAAC;IACjF,OAAO,GAAG,CAAC,OAAO,CAAC;AACrB,CAAC;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,GAAW;IAChC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,IAAI,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;QAAE,OAAO,KAAK,CAAC;IACtC,OAAO,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,SAAiB,EAAE,OAAoB,EAAE;IACrE,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAEzC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,8BAA8B,QAAQ,oDAAoD;YACxF,0CAA0C,CAC7C,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAClD,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IAElD,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC5C,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACtD,EAAE,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;AAC3B,CAAC"}

package/dist/pipeline/load-config.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Runtime loader for a plugin's `aipm.config.ts` envelope (§6.1, P6).
+ *
+ * `aipm.config.ts` is authored in TypeScript and imports `defineConfig` from
+ * `@ai-plugin-marketplace/core`. The build (§5.2) and validate (§5.3) orchestrators need to
+ * evaluate that module at runtime to read its `default` export. We use {@link https://github.com/unjs/jiti | jiti}
+ * to transpile-and-import the TS module on the fly, then re-run it through {@link defineConfig}
+ * so the result is a properly-branded {@link AipmConfig} regardless of what the on-disk module
+ * happened to call.
+ *
+ * **Module resolution.** A plugin's `aipm.config.ts` can live anywhere on disk (including a
+ * temp dir during tests), so a bare `import '@ai-plugin-marketplace/core'` would not resolve
+ * by walking up from the config file. We register a jiti `alias` mapping the package specifier
+ * to this package's own entrypoint, derived from {@link import.meta.url}. The alias is
+ * extension-less so jiti resolves `index.ts` when running from source (vitest) and `index.js`
+ * when running from the compiled `dist/` (production) — both verified working.
+ *
+ * @see docs/specs/architecture.md §6.1 (envelope declaration), P6 (TypeScript end-to-end)
+ * @see docs/specs/architecture.md §5.2, §5.3 (build/validate consume the loaded envelope)
+ */
+import type { AipmConfig } from '../config.js';
+/** The canonical config filename every plugin must provide (§6.1). */
+export declare const AIPM_CONFIG_FILENAME = "aipm.config.ts";
+/**
+ * Error thrown when a plugin's `aipm.config.ts` cannot be located, imported, or validated.
+ * The build orchestrator surfaces this as a thrown error; the validate orchestrator catches it
+ * and converts it into an `envelope-invalid` finding (§10.1 step 1).
+ */
+export declare class ConfigLoadError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Load and validate a plugin's `aipm.config.ts`, returning the branded {@link AipmConfig}.
+ *
+ * The on-disk module's `default` export is re-validated through {@link defineConfig} so callers
+ * receive a value that provably passed the canonical Zod schema — even if the author bypassed
+ * `defineConfig` in their source (e.g. exported a plain object literal).
+ *
+ * @param pluginDir - Absolute path to the `plugins/<name>/` directory.
+ * @returns The validated, branded config.
+ * @throws {ConfigLoadError} If the file is absent, fails to import, has no default export, or
+ *   the default export fails schema validation.
+ */
+export declare function loadPluginConfig(pluginDir: string): Promise<AipmConfig>;
+//# sourceMappingURL=load-config.d.ts.map

package/dist/pipeline/load-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../../src/pipeline/load-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,cAAc,CAAC;AAEhE,sEAAsE;AACtE,eAAO,MAAM,oBAAoB,mBAAmB,CAAC;AAKrD;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAI3D;AAmBD;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA4C7E"}

package/dist/pipeline/load-config.js

@@ -0,0 +1,106 @@
+/**
+ * Runtime loader for a plugin's `aipm.config.ts` envelope (§6.1, P6).
+ *
+ * `aipm.config.ts` is authored in TypeScript and imports `defineConfig` from
+ * `@ai-plugin-marketplace/core`. The build (§5.2) and validate (§5.3) orchestrators need to
+ * evaluate that module at runtime to read its `default` export. We use {@link https://github.com/unjs/jiti | jiti}
+ * to transpile-and-import the TS module on the fly, then re-run it through {@link defineConfig}
+ * so the result is a properly-branded {@link AipmConfig} regardless of what the on-disk module
+ * happened to call.
+ *
+ * **Module resolution.** A plugin's `aipm.config.ts` can live anywhere on disk (including a
+ * temp dir during tests), so a bare `import '@ai-plugin-marketplace/core'` would not resolve
+ * by walking up from the config file. We register a jiti `alias` mapping the package specifier
+ * to this package's own entrypoint, derived from {@link import.meta.url}. The alias is
+ * extension-less so jiti resolves `index.ts` when running from source (vitest) and `index.js`
+ * when running from the compiled `dist/` (production) — both verified working.
+ *
+ * @see docs/specs/architecture.md §6.1 (envelope declaration), P6 (TypeScript end-to-end)
+ * @see docs/specs/architecture.md §5.2, §5.3 (build/validate consume the loaded envelope)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createJiti } from 'jiti';
+import { defineConfig } from '../config.js';
+/** The canonical config filename every plugin must provide (§6.1). */
+export const AIPM_CONFIG_FILENAME = 'aipm.config.ts';
+/** The npm specifier a plugin's `aipm.config.ts` imports `defineConfig` from. */
+const CORE_PACKAGE_SPECIFIER = '@ai-plugin-marketplace/core';
+/**
+ * Error thrown when a plugin's `aipm.config.ts` cannot be located, imported, or validated.
+ * The build orchestrator surfaces this as a thrown error; the validate orchestrator catches it
+ * and converts it into an `envelope-invalid` finding (§10.1 step 1).
+ */
+export class ConfigLoadError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'ConfigLoadError';
+    }
+}
+/**
+ * Absolute path to this package's public entrypoint, **without** a file extension, derived from
+ * the location of this module. When bundled to `dist/pipeline/load-config.js` this resolves to
+ * `dist/index`; when run from source as `src/pipeline/load-config.ts` it resolves to `src/index`.
+ * jiti's resolver appends the correct extension in each case.
+ */
+function corePackageEntrypoint() {
+    const here = fileURLToPath(import.meta.url);
+    // here = <pkgRoot>/<src|dist>/pipeline/load-config.<ts|js>; index sits two levels up.
+    return path.join(path.dirname(here), '..', 'index');
+}
+/** Absolute path to a plugin's `aipm.config.ts`, given the plugin directory. */
+function configPathFor(pluginDir) {
+    return path.join(pluginDir, AIPM_CONFIG_FILENAME);
+}
+/**
+ * Load and validate a plugin's `aipm.config.ts`, returning the branded {@link AipmConfig}.
+ *
+ * The on-disk module's `default` export is re-validated through {@link defineConfig} so callers
+ * receive a value that provably passed the canonical Zod schema — even if the author bypassed
+ * `defineConfig` in their source (e.g. exported a plain object literal).
+ *
+ * @param pluginDir - Absolute path to the `plugins/<name>/` directory.
+ * @returns The validated, branded config.
+ * @throws {ConfigLoadError} If the file is absent, fails to import, has no default export, or
+ *   the default export fails schema validation.
+ */
+export async function loadPluginConfig(pluginDir) {
+    const configPath = configPathFor(pluginDir);
+    if (!fs.existsSync(configPath)) {
+        throw new ConfigLoadError(`No ${AIPM_CONFIG_FILENAME} found in ${pluginDir}. Every plugin must declare a support envelope (spec §6.1).`);
+    }
+    const jiti = createJiti(import.meta.url, {
+        alias: { [CORE_PACKAGE_SPECIFIER]: corePackageEntrypoint() },
+        // Disable the default↔namespace interop so a config with no `default` export reads as a
+        // genuinely-absent default rather than jiti synthesizing one from the namespace.
+        interopDefault: false,
+        // Disable caches so repeated loads (e.g. freshness re-reads) see current disk state.
+        moduleCache: false,
+        fsCache: false,
+    });
+    let mod;
+    try {
+        mod = await jiti.import(configPath);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ConfigLoadError(`Failed to import ${AIPM_CONFIG_FILENAME}: ${message}`, {
+            cause: err,
+        });
+    }
+    const defaultExport = mod['default'];
+    if (defaultExport === undefined || defaultExport === null) {
+        throw new ConfigLoadError(`${AIPM_CONFIG_FILENAME} in ${pluginDir} has no default export. Export the result of \`defineConfig({...})\` as default.`);
+    }
+    // Re-validate through defineConfig so the result is a branded AipmConfig. defineConfig throws
+    // a ZodError on malformed input; wrap it so callers get a single ConfigLoadError type.
+    try {
+        return defineConfig(defaultExport);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ConfigLoadError(`Invalid ${AIPM_CONFIG_FILENAME}: ${message}`, { cause: err });
+    }
+}
+//# sourceMappingURL=load-config.js.map

package/dist/pipeline/load-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-config.js","sourceRoot":"","sources":["../../src/pipeline/load-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,sEAAsE;AACtE,MAAM,CAAC,MAAM,oBAAoB,GAAG,gBAAgB,CAAC;AAErD,iFAAiF;AACjF,MAAM,sBAAsB,GAAG,6BAA6B,CAAC;AAE7D;;;;GAIG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IACxC,YAAY,OAAe,EAAE,OAA6B;QACxD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,qBAAqB;IAC5B,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5C,sFAAsF;IACtF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AACtD,CAAC;AAED,gFAAgF;AAChF,SAAS,aAAa,CAAC,SAAiB;IACtC,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,SAAiB;IACtD,MAAM,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IAE5C,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,eAAe,CACvB,MAAM,oBAAoB,aAAa,SAAS,6DAA6D,CAC9G,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;QACvC,KAAK,EAAE,EAAE,CAAC,sBAAsB,CAAC,EAAE,qBAAqB,EAAE,EAAE;QAC5D,wFAAwF;QACxF,iFAAiF;QACjF,cAAc,EAAE,KAAK;QACrB,qFAAqF;QACrF,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,KAAK;KACf,CAAC,CAAC;IAEH,IAAI,GAA4B,CAAC;IACjC,IAAI,CAAC;QACH,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAA0B,UAAU,CAAC,CAAC;IAC/D,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjE,MAAM,IAAI,eAAe,CAAC,oBAAoB,oBAAoB,KAAK,OAAO,EAAE,EAAE;YAChF,KAAK,EAAE,GAAG;SACX,CAAC,CAAC;IACL,CAAC;IAED,MAAM,aAAa,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;IACrC,IAAI,aAAa,KAAK,SAAS,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;QAC1D,MAAM,IAAI,eAAe,CACvB,GAAG,oBAAoB,OAAO,SAAS,kFAAkF,CAC1H,CAAC;IACJ,CAAC;IAED,8FAA8F;IAC9F,uFAAuF;IACvF,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,aAAgC,CAAC,CAAC;IACxD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjE,MAAM,IAAI,eAAe,CAAC,WAAW,oBAAoB,KAAK,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IAC3F,CAAC;AACH,CAAC"}

package/dist/pipeline/operations.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Public operation implementations.
+ *
+ * Each function here is a thin adapter over a pipeline orchestrator, with the pinned public
+ * signature from §8.1 of the spec. Business logic lives in the orchestrators
+ * (`build.ts`, `validate.ts`, `scaffold.ts`); this module only adapts arguments (e.g. deriving
+ * the plugins directory from the cwd for `scaffold`, and reading the CI environment for the
+ * freshness severity) so the public contract stays stable as implementations evolve.
+ *
+ * @see docs/specs/architecture.md §8.1
+ */
+import type { BuildOptions, BuildResult, InitOptions, MigrateOptions, MigrateResult, ScaffoldOptions, SupportReport, TargetId, ValidateOptions, ValidationResult } from './types.js';
+/**
+ * Build a single plugin or every plugin under a repo root. `path` may be a plugin directory
+ * (contains `aipm.config.ts`) or a repo root (contains `plugins/`); the orchestrator detects
+ * which and returns a length-1 array for single-plugin input. See §5.2, §8.1.
+ *
+ * @public
+ */
+export declare function build(targetPath: string, opts?: BuildOptions): Promise<BuildResult[]>;
+/**
+ * Validate a single plugin or every plugin under a repo root, in the order defined by §10.1.
+ * Freshness severity follows the CI environment (§10.2).
+ *
+ * @public
+ */
+export declare function validate(targetPath: string, opts?: ValidateOptions): Promise<ValidationResult>;
+/**
+ * Scaffold a thin consumer repo (the "template") at `targetDir` that depends on
+ * `@ai-plugin-marketplace/cli` and holds plugin sources only (§3.2, §11). The generated
+ * `package.json` pins the cli dev dependency to a caret of the current toolkit version (§9.1
+ * lockstep). Refuses to write into a non-empty directory.
+ *
+ * @public
+ */
+export declare function init(targetDir: string, opts?: InitOptions): Promise<void>;
+/**
+ * Scaffold a new plugin under `<cwd>/plugins/<name>`. The plugins directory is derived from the
+ * current working directory, matching how `aipm scaffold` is invoked from a template repo root.
+ *
+ * @public
+ */
+export declare function scaffold(name: string, opts?: ScaffoldOptions): Promise<void>;
+/**
+ * No-op in v0.1.0 per §8.1 of the spec. Always returns `status: 'no-migrations-needed'` because
+ * §9.4 constrains every `schemaVersion` to a single value. When real migrations ship, this
+ * must distinguish up-to-date from unknown-future-version.
+ *
+ * @public
+ */
+export declare function migrate(_path: string, _opts?: MigrateOptions): Promise<MigrateResult>;
+/**
+ * Diagnose a plugin's support envelope: declared targets, missing artifacts, addable targets (§6.4).
+ *
+ * @public
+ */
+export declare function checkSupport(pluginDir: string): Promise<SupportReport>;
+/**
+ * Scaffold skeleton files for a new target in an existing plugin (§6.4).
+ *
+ * @public
+ */
+export declare function addTarget(pluginDir: string, target: TargetId): Promise<void>;
+/**
+ * List the target IDs this toolkit version knows about (§6.4).
+ *
+ * @public
+ */
+export declare function listTargets(): readonly TargetId[];
+//# sourceMappingURL=operations.d.ts.map

package/dist/pipeline/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../src/pipeline/operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AASH,OAAO,KAAK,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,cAAc,EACd,aAAa,EACb,eAAe,EACf,aAAa,EACb,QAAQ,EACR,eAAe,EACf,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAOpB;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAErF;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAE9F;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhF;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAMrF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAEtE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,SAAS,QAAQ,EAAE,CAEjD"}

package/dist/pipeline/operations.js

@@ -0,0 +1,100 @@
+/**
+ * Public operation implementations.
+ *
+ * Each function here is a thin adapter over a pipeline orchestrator, with the pinned public
+ * signature from §8.1 of the spec. Business logic lives in the orchestrators
+ * (`build.ts`, `validate.ts`, `scaffold.ts`); this module only adapts arguments (e.g. deriving
+ * the plugins directory from the cwd for `scaffold`, and reading the CI environment for the
+ * freshness severity) so the public contract stays stable as implementations evolve.
+ *
+ * @see docs/specs/architecture.md §8.1
+ */
+import * as path from 'node:path';
+import { runBuild } from './build.js';
+import { runInit } from './init.js';
+import { runScaffold, runAddTarget, runCheckSupport } from './scaffold.js';
+import { TARGET_IDS } from './types.js';
+import { runValidate } from './validate.js';
+/** True when running in a CI environment. Freshness findings are hard in CI, soft locally (§10.2). */
+function isCi() {
+    return Boolean(process.env['CI']);
+}
+/**
+ * Build a single plugin or every plugin under a repo root. `path` may be a plugin directory
+ * (contains `aipm.config.ts`) or a repo root (contains `plugins/`); the orchestrator detects
+ * which and returns a length-1 array for single-plugin input. See §5.2, §8.1.
+ *
+ * @public
+ */
+export function build(targetPath, opts) {
+    return runBuild(targetPath, opts);
+}
+/**
+ * Validate a single plugin or every plugin under a repo root, in the order defined by §10.1.
+ * Freshness severity follows the CI environment (§10.2).
+ *
+ * @public
+ */
+export function validate(targetPath, opts) {
+    return runValidate(targetPath, { ...opts, ci: isCi() });
+}
+/**
+ * Scaffold a thin consumer repo (the "template") at `targetDir` that depends on
+ * `@ai-plugin-marketplace/cli` and holds plugin sources only (§3.2, §11). The generated
+ * `package.json` pins the cli dev dependency to a caret of the current toolkit version (§9.1
+ * lockstep). Refuses to write into a non-empty directory.
+ *
+ * @public
+ */
+export function init(targetDir, opts) {
+    return runInit(targetDir, opts);
+}
+/**
+ * Scaffold a new plugin under `<cwd>/plugins/<name>`. The plugins directory is derived from the
+ * current working directory, matching how `aipm scaffold` is invoked from a template repo root.
+ *
+ * @public
+ */
+export function scaffold(name, opts = {}) {
+    const pluginsDir = path.join(process.cwd(), 'plugins');
+    return runScaffold(name, pluginsDir, opts);
+}
+/**
+ * No-op in v0.1.0 per §8.1 of the spec. Always returns `status: 'no-migrations-needed'` because
+ * §9.4 constrains every `schemaVersion` to a single value. When real migrations ship, this
+ * must distinguish up-to-date from unknown-future-version.
+ *
+ * @public
+ */
+export function migrate(_path, _opts) {
+    return Promise.resolve({
+        status: 'no-migrations-needed',
+        migrationsApplied: 0,
+        filesChanged: [],
+    });
+}
+/**
+ * Diagnose a plugin's support envelope: declared targets, missing artifacts, addable targets (§6.4).
+ *
+ * @public
+ */
+export function checkSupport(pluginDir) {
+    return runCheckSupport(pluginDir);
+}
+/**
+ * Scaffold skeleton files for a new target in an existing plugin (§6.4).
+ *
+ * @public
+ */
+export function addTarget(pluginDir, target) {
+    return runAddTarget(pluginDir, target);
+}
+/**
+ * List the target IDs this toolkit version knows about (§6.4).
+ *
+ * @public
+ */
+export function listTargets() {
+    return TARGET_IDS;
+}
+//# sourceMappingURL=operations.js.map

package/dist/pipeline/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","sourceRoot":"","sources":["../../src/pipeline/operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAc5C,sGAAsG;AACtG,SAAS,IAAI;IACX,OAAO,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAC,UAAkB,EAAE,IAAmB;IAC3D,OAAO,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,UAAkB,EAAE,IAAsB;IACjE,OAAO,WAAW,CAAC,UAAU,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAAC,SAAiB,EAAE,IAAkB;IACxD,OAAO,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAClC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY,EAAE,OAAwB,EAAE;IAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,SAAS,CAAC,CAAC;IACvD,OAAO,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAC,KAAa,EAAE,KAAsB;IAC3D,OAAO,OAAO,CAAC,OAAO,CAAC;QACrB,MAAM,EAAE,sBAAsB;QAC9B,iBAAiB,EAAE,CAAC;QACpB,YAAY,EAAE,EAAE;KACjB,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,SAAiB;IAC5C,OAAO,eAAe,CAAC,SAAS,CAAC,CAAC;AACpC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,SAAiB,EAAE,MAAgB;IAC3D,OAAO,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW;IACzB,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/pipeline/scaffold.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Pipeline orchestration for scaffolding and compatibility-assist (§6.4).
+ *
+ * Three orchestrators perform filesystem I/O around the per-target *pure* scaffold functions:
+ *
+ *   - `runScaffold`     — create a brand-new plugin (the `aipm scaffold` surface).
+ *   - `runAddTarget`    — add one target's skeleton to an existing plugin (`aipm add-target`).
+ *   - `runCheckSupport` — report declared-but-incomplete and plausibly-addable targets
+ *                          (`aipm check-support`).
+ *
+ * Per §3.4/§12.4 the pipeline layer is the orchestration boundary and MAY import each target's
+ * `scaffold.ts`; the per-target scaffold modules themselves never import one another.
+ *
+ * Envelope reading (§6.1): loading and executing a TypeScript `aipm.config.ts` from disk is the
+ * build orchestrator's job and is not yet built. `runCheckSupport`/`runAddTarget` therefore read
+ * the declared targets *pragmatically* — by extracting the `targets: [...]` array literal out of
+ * the config source text (see `parseDeclaredTargets`). This tolerates the canonical
+ * `defineConfig({ ... })` form this module emits and common hand-authored variants, but it is a
+ * lexical heuristic, not a TS evaluation. Documented limitation: a config that computes `targets`
+ * dynamically (spread, variable reference, conditional) is not understood and yields an error.
+ *
+ * @see docs/specs/architecture.md §6 (support envelope)
+ * @see docs/specs/architecture.md §6.4 (compatibility-assist tooling)
+ * @see docs/specs/architecture.md §10.1 (validation contract — artifact tables reused here)
+ * @see docs/specs/architecture.md §12.5 (per-target scaffold.ts)
+ */
+import type { ScaffoldOptions, SupportReport, TargetId } from './types.js';
+/**
+ * Validate a plugin name against the canonical slug rules shared by every manifest schema:
+ * lowercase, starts with a letter, `[a-z0-9-]` only, no consecutive hyphens, no trailing hyphen.
+ *
+ * @throws Error with a clear message when the name is invalid.
+ */
+export declare function validatePluginName(name: string): void;
+/**
+ * Render the canonical `aipm.config.ts` source for a plugin with the given targets.
+ *
+ * Emits a `defineConfig({ version, targets })` literal importing from the public package root
+ * (§8.1 — the only public subpath). Deterministic: stable target ordering, no timestamps.
+ */
+export declare function renderAipmConfig(targets: readonly TargetId[]): string;
+/**
+ * Extract the declared targets from `aipm.config.ts` source text.
+ *
+ * Lexical heuristic (see module doc): finds the first `targets:` key and parses the immediately
+ * following `[...]` array of single/double-quoted string literals. Only IDs in `TARGET_IDS` are
+ * returned; unknown IDs are ignored (the shape validator surfaces those separately).
+ *
+ * @returns Declared target IDs in canonical order, deduplicated.
+ * @throws Error when no `targets: [...]` array literal can be located.
+ */
+export declare function parseDeclaredTargets(configSource: string): TargetId[];
+/**
+ * Create a brand-new plugin under `pluginsDir/<name>/`.
+ *
+ * Writes `aipm.config.ts` (via the `defineConfig` literal), each declared target's skeleton
+ * files, and the canonical `README.md` / `LICENSE`. Default targets are all known IDs when
+ * `opts.targets` is absent.
+ *
+ * Also registers the plugin in the template-level marketplace registries (§4.4) for each of
+ * Claude/Cursor in the envelope (`repoRoot = dirname(pluginsDir)`), so the scaffolded plugin
+ * passes `validate`'s `marketplace-registration` check (§10.1.4) out of the box.
+ *
+ * @throws Error when `name` is invalid or the plugin directory already exists.
+ */
+export declare function runScaffold(name: string, pluginsDir: string, opts?: ScaffoldOptions): Promise<void>;
+/**
+ * Scaffold one target's skeleton files into an existing plugin (§6.4 `aipm add-target`).
+ *
+ * Manifest fields are emitted as placeholders for the author to complete. Existing files are
+ * NEVER clobbered: if any file this target would write already exists, the function refuses and
+ * throws — the author resolves the conflict deliberately.
+ *
+ * The plugin's `aipm.config.ts` is updated to include `target` in its `targets` array when the
+ * lexical reader can locate the array (see module doc). Limitation: if the array cannot be parsed
+ * (dynamic/computed targets), the config is left untouched and the error message instructs the
+ * author to add the target manually — the function never leaves the envelope silently
+ * inconsistent.
+ *
+ * When `target` is Claude or Cursor, the plugin is also registered in the corresponding
+ * repo-root marketplace registry (§4.4) so adding the target keeps `validate` green. repoRoot is
+ * the plugin's grandparent (`<repoRoot>/plugins/<name>`), matching `discoverPlugins`.
+ *
+ * @throws Error when `pluginDir` does not exist, a target file already exists, or the config's
+ * targets array cannot be located for the update.
+ */
+export declare function runAddTarget(pluginDir: string, target: TargetId): Promise<void>;
+/**
+ * Report a plugin's support posture (§6.4 `aipm check-support`).
+ *
+ * Reads the declared envelope from `aipm.config.ts` (lexically — see module doc), then:
+ *   - `missingArtifacts`: for each declared target, the `TARGET_MIN_REQUIRED` files absent on disk
+ *     (Vercel's "at least one SKILL.md under a skills subdirectory" rule is applied specially,
+ *     mirroring the
+ *     validator). Only targets with at least one missing artifact appear.
+ *   - `suggestions`: each undeclared known target, with `wouldNeed` = that target's min-required
+ *     files (the concrete list of files the author would write to add it).
+ *
+ * Reuses the validator's `TARGET_MIN_REQUIRED` table so "missing" stays consistent with
+ * `aipm validate`.
+ *
+ * @throws Error when `pluginDir` or its `aipm.config.ts` is missing, or the envelope is unreadable.
+ */
+export declare function runCheckSupport(pluginDir: string): Promise<SupportReport>;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/pipeline/scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../src/pipeline/scaffold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAaH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AA0B3E;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAerD;AAMD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CAUrE;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,EAAE,CAcrE;AAmJD;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC,IAAI,CAAC,CA8Bf;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAgCrF;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA+B/E"}