@monosmith/plugin-sdk 2.0.0-beta.4 → 2.0.0-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monosmith/plugin-sdk",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.6",
   "description": "The TypeScript SDK for writing smith plugins: the protocol's types, the serve loop, a test host, the conformance checks, templating and key-order-keeping JSON editing. No runtime dependencies.",
   "license": "MIT",
   "type": "module",

package/protocol/protocol-schema.contract.js

@@ -175,6 +175,28 @@ export const protocolSchema = {
             "capability": "dependencies",
             "notification": false
         },
+        "dependencies/link": {
+            "description": "Makes a project depend on a library of the same workspace and language, in the ecosystem's own form, then installs or locks as that needs.",
+            "params": {
+                "$ref": "#/$defs/LinkParams"
+            },
+            "result": {
+                "$ref": "#/$defs/LinkResult"
+            },
+            "capability": "link",
+            "notification": false
+        },
+        "dependencies/unlink": {
+            "description": "Removes the dependency of a project on a library of the same workspace.",
+            "params": {
+                "$ref": "#/$defs/UnlinkParams"
+            },
+            "result": {
+                "$ref": "#/$defs/DependencyResult"
+            },
+            "capability": "link",
+            "notification": false
+        },
         "dependencies/declared": {
             "description": "Lists the dependencies the manifests of the plugin's projects declare.",
             "params": {
@@ -589,6 +611,10 @@ export const protocolSchema = {
                     "type": "boolean",
                     "description": "Dependencies installs and uninstalls packages in its projects."
                 },
+                "link": {
+                    "type": "boolean",
+                    "description": "Link makes a project depend on a library of the same workspace in the ecosystem's own form (a workspace dependency, a path dependency, a project reference), and takes it out again. A plugin without it is refused by the host with one sentence that tells the user to add the dependency by hand."
+                },
                 "declarations": {
                     "type": "boolean",
                     "description": "Declarations lists and rewrites declared dependency specs (sync, up)."
@@ -692,6 +718,21 @@ export const protocolSchema = {
                 "description": {
                     "type": "string"
                 },
+                "title": {
+                    "type": "string",
+                    "description": "Title is the name shown to a person (\"Electron\" for electron). Without it the name is shown."
+                },
+                "aliases": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Aliases are words that find the choice when a person searches the catalogue (smith compose): \"desktop\", \"serverless\", \"web\"."
+                },
+                "layer": {
+                    "type": "string",
+                    "description": "Layer is where the choice sits in the stack of a project: \"framework\", \"shell\" (a desktop shell), \"host\" (where cloud code runs), \"test\", \"lint\", \"style\" or a layer of the plugin's own. Without it the layer is the axis. It is for display and grouping: the axis decides conflicts."
+                },
                 "language": {
                     "type": "string",
                     "description": "Language is the language plugin the choice applies to (\"node\")."
@@ -714,6 +755,10 @@ export const protocolSchema = {
                     "type": "boolean",
                     "description": "Default marks the choice the host adds when a selection needs its axis and has no choice on it."
                 },
+                "suggested": {
+                    "type": "boolean",
+                    "description": "Suggested marks the choice an asker pre-selects on its axis. The solver never adds it by itself: an axis that a choice needs and that has no Default is asked, and the person answers (ADR 0072)."
+                },
                 "many": {
                     "type": "boolean",
                     "description": "Many allows the choice next to other choices of its axis that are Many too. By default a selection has one choice per axis."
@@ -1589,6 +1634,13 @@ export const protocolSchema = {
                         "$ref": "#/$defs/Choice"
                     },
                     "description": "Choices are the options on an axis (framework, test, style) the plugin owns. The host lists them (smith choices) and checks a selection of them (smith add --with). Absent means the plugin owns none."
+                },
+                "tools": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/ToolNeed"
+                    },
+                    "description": "Tools are the programs the plugin needs on the person's machine. The host detects them and, when one is missing, presents the ways to get it (smith tools). Absent means the plugin declares none."
                 }
             },
             "required": [
@@ -1685,6 +1737,94 @@ export const protocolSchema = {
                 }
             }
         },
+        "LinkOption": {
+            "description": "LinkOption is one way to write the dependency, with its consequence in words a person who read no manual can follow.",
+            "type": "object",
+            "properties": {
+                "spec": {
+                    "type": "string",
+                    "description": "Spec is the value passed back in LinkParams.Spec."
+                },
+                "label": {
+                    "type": "string",
+                    "description": "Label is the option in a few words."
+                },
+                "meaning": {
+                    "type": "string",
+                    "description": "Meaning says what happens with this option."
+                }
+            },
+            "required": [
+                "spec",
+                "label",
+                "meaning"
+            ]
+        },
+        "LinkParams": {
+            "description": "LinkParams asks a plugin to make Project depend on Library, a lib or package of the same workspace and language, in the ecosystem's own form, and to install or lock as that needs. The host has checked that both exist, that the languages match, that Library is not an app, and that the link makes no cycle; the plugin answers with an error that names the file when it cannot write the dependency.",
+            "type": "object",
+            "properties": {
+                "project": {
+                    "$ref": "#/$defs/Project",
+                    "description": "Project is the project that gains the dependency."
+                },
+                "library": {
+                    "$ref": "#/$defs/Project",
+                    "description": "Library is the project it depends on."
+                },
+                "quiet": {
+                    "type": "boolean",
+                    "description": "Quiet keeps the package manager's output unless it fails."
+                },
+                "plan": {
+                    "type": "boolean",
+                    "description": "Plan asks for the plan only: the plugin writes nothing and answers with the manifest, the line it would write and the choices the user has."
+                },
+                "spec": {
+                    "type": "string",
+                    "description": "Spec is the version range the user chose from LinkResult.Options; empty means the plugin's default, or the form the workspace already uses."
+                }
+            },
+            "required": [
+                "project",
+                "library"
+            ]
+        },
+        "LinkResult": {
+            "description": "LinkResult is what a link wrote, or with LinkParams.Plan would write.",
+            "type": "object",
+            "properties": {
+                "files": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Files are the workspace-relative files changed (or to be changed)."
+                },
+                "notes": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Notes are for the user."
+                },
+                "manifest": {
+                    "type": "string",
+                    "description": "Manifest is the file the dependency goes into, workspace-relative."
+                },
+                "line": {
+                    "type": "string",
+                    "description": "Line is the dependency as it is written there, for the plan shown before anything is written (\"@acme/core\": \"*\")."
+                },
+                "options": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/LinkOption"
+                    },
+                    "description": "Options are the real choices of the range written, with the default first. Empty when the ecosystem has none, or the workspace already follows a convention (then Line shows it)."
+                }
+            }
+        },
         "PackageStore": {
             "description": "PackageStore is where a package manager keeps what it downloaded (npm's ~/.npm, Go's module cache). A generated pipeline restores it before setup and saves it after a run, keyed on Files, so `npm ci` or `go mod download` fetches only what changed. A pull request from a fork restores it and never writes the base repository's cache.",
             "type": "object",
@@ -1924,6 +2064,13 @@ export const protocolSchema = {
                 "registry": {
                     "type": "string"
                 },
+                "notes": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Notes are things the person must know about a publish that succeeded, such as a dist-tag that was not moved; the host prints them and the report keeps them."
+                },
                 "assets": {
                     "type": "array",
                     "items": {
@@ -2402,6 +2549,121 @@ export const protocolSchema = {
                 "command"
             ]
         },
+        "ToolInstall": {
+            "description": "ToolInstall is one way to get a tool with a package manager. Manager is one of: \"winget\", \"brew\", \"brew-cask\", \"apt\", \"dnf\", \"pacman\", \"npm\", \"uv\", \"fnm\" and \"rustup\". The host builds the exact command from the manager and Package; Package may hold {major} and {major.minor}, which the pinned or suggested version fills. The language's own installers (uv, fnm, rustup) are offered only when they are already on the machine.",
+            "type": "object",
+            "properties": {
+                "manager": {
+                    "type": "string"
+                },
+                "package": {
+                    "type": "string"
+                },
+                "note": {
+                    "type": "string",
+                    "description": "Note adds a sentence the person needs before choosing (\"a new terminal is needed\")."
+                }
+            },
+            "required": [
+                "manager",
+                "package"
+            ]
+        },
+        "ToolNeed": {
+            "description": "ToolNeed is a program on the person's machine that a plugin needs to build, test or run its projects (Python, the .NET SDK, Docker). A plugin publishes the tools it needs in InitializeResult.Tools. The host detects them, and when one is missing it presents the ways to get it (ADR 0077): it never installs in silence. The plugin writes facts only (what the tool is, how to detect it, how each system gets it); the host decides how to ask.",
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Name identifies the tool across plugins and in commands (smith tools install python). Two plugins that need the same tool use the same Name."
+                },
+                "title": {
+                    "type": "string",
+                    "description": "Title is what the tool is called in text: \"Python\", \"the .NET SDK\". Doctor words the check \"<Title> is installed\"."
+                },
+                "why": {
+                    "type": "string",
+                    "description": "Why says in plain words what smith needs the tool for."
+                },
+                "consequence": {
+                    "type": "string",
+                    "description": "Consequence says what stops working while the tool is missing, as the end of a sentence that starts \"If you skip it, \": \"smith test and smith build fail for the python projects\"."
+                },
+                "program": {
+                    "type": "string",
+                    "description": "Program is the program that carries the tool on PATH (\"python3\")."
+                },
+                "alternatives": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Alternatives are other programs that also count (\"python\", \"py\")."
+                },
+                "versionArgs": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "VersionArgs are the arguments that make Program print its version. Absent means --version."
+                },
+                "pins": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/ToolVersionPin"
+                    },
+                    "description": "Pins are the files where a workspace pins the version it wants. The first pin the host finds gives the version range. Absent means any version counts."
+                },
+                "choice": {
+                    "type": "string",
+                    "description": "Choice limits the tool to stacks that have this choice (\"azure-functions\"): the tool is not needed by a project built without it. Absent means every project of the plugin needs it."
+                },
+                "systems": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Systems limits the tool to these systems, named as Go names them (\"windows\", \"darwin\", \"linux\"): the Xcode Command Line Tools exist only on \"darwin\". Absent means every system."
+                },
+                "suggested": {
+                    "type": "string",
+                    "description": "Suggested is the version smith installs when no pin says one: \"3.13\". It fills {major} and {major.minor} in the install entries."
+                },
+                "optional": {
+                    "type": "boolean",
+                    "description": "Optional marks a tool whose absence only costs a feature (running a function app locally). Doctor reports it as a warning, not a failure."
+                },
+                "install": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/ToolInstall"
+                    },
+                    "description": "Install are the ways to get the tool, per package manager and system."
+                },
+                "download": {
+                    "type": "string",
+                    "description": "Download is the official page of the tool, for the person who installs it by hand or has no package manager."
+                },
+                "source": {
+                    "type": "string",
+                    "description": "Source is the address of the page the Install entries were checked against."
+                },
+                "checked": {
+                    "type": "string",
+                    "description": "Checked is the date (YYYY-MM-DD) the entries were last checked."
+                }
+            },
+            "required": [
+                "name",
+                "title",
+                "why",
+                "consequence",
+                "program",
+                "download",
+                "source",
+                "checked"
+            ]
+        },
         "ToolPin": {
             "description": "ToolPin is a tool the plugin installs at a pinned version (in CI, the dev container, the venv) against the newest release; informational.",
             "type": "object",
@@ -2426,6 +2688,23 @@ export const protocolSchema = {
                 "pinned"
             ]
         },
+        "ToolVersionPin": {
+            "description": "ToolVersionPin names a file that pins the version of a tool and how to read it. Format is one of: \"text\" (the first word of the file, as in .nvmrc and .python-version), \"go-mod\" (the toolchain line, else the go line), \"pyproject\" (requires-python), \"global-json\" (sdk.version) and \"rust-toolchain\" (the channel).",
+            "type": "object",
+            "properties": {
+                "file": {
+                    "type": "string",
+                    "description": "File is the base name of the file, looked up at the workspace root and in the folders of the projects that use the tool."
+                },
+                "format": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "file",
+                "format"
+            ]
+        },
         "Toolchain": {
             "description": "Toolchain is a runtime the pipeline must install, and how. Plugins asking for the same name share one setup step (the first plugin's).",
             "type": "object",
@@ -2477,6 +2756,22 @@ export const protocolSchema = {
                 "packages"
             ]
         },
+        "UnlinkParams": {
+            "description": "UnlinkParams asks a plugin to remove the dependency of Project on Library. Notes of the result say so when the manifest held no such dependency.",
+            "type": "object",
+            "properties": {
+                "project": {
+                    "$ref": "#/$defs/Project"
+                },
+                "library": {
+                    "$ref": "#/$defs/Project"
+                }
+            },
+            "required": [
+                "project",
+                "library"
+            ]
+        },
         "VersionParams": {
             "description": "VersionParams asks a plugin to record a new version in a project manifest.",
             "type": "object",

package/protocol/protocol-types.contract.d.ts

@@ -177,6 +177,13 @@ export interface Capabilities {
     published?: boolean;
     /** Dependencies installs and uninstalls packages in its projects. */
     dependencies?: boolean;
+    /**
+     * Link makes a project depend on a library of the same workspace in the ecosystem's own form (a
+     * workspace dependency, a path dependency, a project reference), and takes it out again. A plugin
+     * without it is refused by the host with one sentence that tells the user to add the dependency
+     * by hand.
+     */
+    link?: boolean;
     /** Declarations lists and rewrites declared dependency specs (sync, up). */
     declarations?: boolean;
     /** Latest reports the newest releases of dependencies and pinned tools. */
@@ -272,6 +279,19 @@ export interface Choice {
      */
     name: string;
     description?: string;
+    /** Title is the name shown to a person ("Electron" for electron). Without it the name is shown. */
+    title?: string;
+    /**
+     * Aliases are words that find the choice when a person searches the catalogue (smith compose):
+     * "desktop", "serverless", "web".
+     */
+    aliases?: string[];
+    /**
+     * Layer is where the choice sits in the stack of a project: "framework", "shell" (a desktop
+     * shell), "host" (where cloud code runs), "test", "lint", "style" or a layer of the plugin's own.
+     * Without it the layer is the axis. It is for display and grouping: the axis decides conflicts.
+     */
+    layer?: string;
     /** Language is the language plugin the choice applies to ("node"). */
     language: string;
     /**
@@ -287,6 +307,12 @@ export interface Choice {
     needs?: string[];
     /** Default marks the choice the host adds when a selection needs its axis and has no choice on it. */
     default?: boolean;
+    /**
+     * Suggested marks the choice an asker pre-selects on its axis. The solver never adds it by
+     * itself: an axis that a choice needs and that has no Default is asked, and the person answers
+     * (ADR 0072).
+     */
+    suggested?: boolean;
     /**
      * Many allows the choice next to other choices of its axis that are Many too. By default a
      * selection has one choice per axis.
@@ -773,6 +799,12 @@ export interface InitializeResult {
      * owns none.
      */
     choices?: Choice[];
+    /**
+     * Tools are the programs the plugin needs on the person's machine. The host detects them and,
+     * when one is missing, presents the ways to get it (smith tools). Absent means the plugin
+     * declares none.
+     */
+    tools?: ToolNeed[];
 }
 /**
  * Input is one input of an ActionStep. Values are written as quoted YAML strings, except true and
@@ -825,6 +857,62 @@ export interface LatestResult {
     unreachable?: Record<string, string>;
     tools?: ToolPin[];
 }
+/**
+ * LinkOption is one way to write the dependency, with its consequence in words a person who read no
+ * manual can follow.
+ */
+export interface LinkOption {
+    /** Spec is the value passed back in LinkParams.Spec. */
+    spec: string;
+    /** Label is the option in a few words. */
+    label: string;
+    /** Meaning says what happens with this option. */
+    meaning: string;
+}
+/**
+ * LinkParams asks a plugin to make Project depend on Library, a lib or package of the same
+ * workspace and language, in the ecosystem's own form, and to install or lock as that needs. The
+ * host has checked that both exist, that the languages match, that Library is not an app, and that
+ * the link makes no cycle; the plugin answers with an error that names the file when it cannot
+ * write the dependency.
+ */
+export interface LinkParams {
+    /** Project is the project that gains the dependency. */
+    project: Project;
+    /** Library is the project it depends on. */
+    library: Project;
+    /** Quiet keeps the package manager's output unless it fails. */
+    quiet?: boolean;
+    /**
+     * Plan asks for the plan only: the plugin writes nothing and answers with the manifest, the line
+     * it would write and the choices the user has.
+     */
+    plan?: boolean;
+    /**
+     * Spec is the version range the user chose from LinkResult.Options; empty means the plugin's
+     * default, or the form the workspace already uses.
+     */
+    spec?: string;
+}
+/** LinkResult is what a link wrote, or with LinkParams.Plan would write. */
+export interface LinkResult {
+    /** Files are the workspace-relative files changed (or to be changed). */
+    files?: string[];
+    /** Notes are for the user. */
+    notes?: string[];
+    /** Manifest is the file the dependency goes into, workspace-relative. */
+    manifest?: string;
+    /**
+     * Line is the dependency as it is written there, for the plan shown before anything is written
+     * ("@acme/core": "*").
+     */
+    line?: string;
+    /**
+     * Options are the real choices of the range written, with the default first. Empty when the
+     * ecosystem has none, or the workspace already follows a convention (then Line shows it).
+     */
+    options?: LinkOption[];
+}
 /**
  * PackageStore is where a package manager keeps what it downloaded (npm's ~/.npm, Go's module
  * cache). A generated pipeline restores it before setup and saves it after a run, keyed on Files,
@@ -1012,6 +1100,11 @@ export interface PublishResult {
     published: boolean;
     skipped?: string;
     registry?: string;
+    /**
+     * Notes are things the person must know about a publish that succeeded, such as a dist-tag that
+     * was not moved; the host prints them and the report keeps them.
+     */
+    notes?: string[];
     /**
      * Assets are the workspace-relative files built for the release, in upload order; in a dry run,
      * the files that would be built.
@@ -1258,6 +1351,87 @@ export interface Task {
     /** ServeTimeout is how long to wait for ServeURL, as a Go duration ("60s"); empty means 60s. */
     serveTimeout?: string;
 }
+/**
+ * ToolInstall is one way to get a tool with a package manager. Manager is one of: "winget", "brew",
+ * "brew-cask", "apt", "dnf", "pacman", "npm", "uv", "fnm" and "rustup". The host builds the exact
+ * command from the manager and Package; Package may hold {major} and {major.minor}, which the
+ * pinned or suggested version fills. The language's own installers (uv, fnm, rustup) are offered
+ * only when they are already on the machine.
+ */
+export interface ToolInstall {
+    manager: string;
+    package: string;
+    /** Note adds a sentence the person needs before choosing ("a new terminal is needed"). */
+    note?: string;
+}
+/**
+ * ToolNeed is a program on the person's machine that a plugin needs to build, test or run its
+ * projects (Python, the .NET SDK, Docker). A plugin publishes the tools it needs in
+ * InitializeResult.Tools. The host detects them, and when one is missing it presents the ways to
+ * get it (ADR 0077): it never installs in silence. The plugin writes facts only (what the tool is,
+ * how to detect it, how each system gets it); the host decides how to ask.
+ */
+export interface ToolNeed {
+    /**
+     * Name identifies the tool across plugins and in commands (smith tools install python). Two
+     * plugins that need the same tool use the same Name.
+     */
+    name: string;
+    /**
+     * Title is what the tool is called in text: "Python", "the .NET SDK". Doctor words the check
+     * "<Title> is installed".
+     */
+    title: string;
+    /** Why says in plain words what smith needs the tool for. */
+    why: string;
+    /**
+     * Consequence says what stops working while the tool is missing, as the end of a sentence that
+     * starts "If you skip it, ": "smith test and smith build fail for the python projects".
+     */
+    consequence: string;
+    /** Program is the program that carries the tool on PATH ("python3"). */
+    program: string;
+    /** Alternatives are other programs that also count ("python", "py"). */
+    alternatives?: string[];
+    /** VersionArgs are the arguments that make Program print its version. Absent means --version. */
+    versionArgs?: string[];
+    /**
+     * Pins are the files where a workspace pins the version it wants. The first pin the host finds
+     * gives the version range. Absent means any version counts.
+     */
+    pins?: ToolVersionPin[];
+    /**
+     * Choice limits the tool to stacks that have this choice ("azure-functions"): the tool is not
+     * needed by a project built without it. Absent means every project of the plugin needs it.
+     */
+    choice?: string;
+    /**
+     * Systems limits the tool to these systems, named as Go names them ("windows", "darwin",
+     * "linux"): the Xcode Command Line Tools exist only on "darwin". Absent means every system.
+     */
+    systems?: string[];
+    /**
+     * Suggested is the version smith installs when no pin says one: "3.13". It fills {major} and
+     * {major.minor} in the install entries.
+     */
+    suggested?: string;
+    /**
+     * Optional marks a tool whose absence only costs a feature (running a function app locally).
+     * Doctor reports it as a warning, not a failure.
+     */
+    optional?: boolean;
+    /** Install are the ways to get the tool, per package manager and system. */
+    install?: ToolInstall[];
+    /**
+     * Download is the official page of the tool, for the person who installs it by hand or has no
+     * package manager.
+     */
+    download: string;
+    /** Source is the address of the page the Install entries were checked against. */
+    source: string;
+    /** Checked is the date (YYYY-MM-DD) the entries were last checked. */
+    checked: string;
+}
 /**
  * ToolPin is a tool the plugin installs at a pinned version (in CI, the dev container, the venv)
  * against the newest release; informational.
@@ -1270,6 +1444,20 @@ export interface ToolPin {
     /** Newer is true when Latest is a release the pin does not cover. */
     newer?: boolean;
 }
+/**
+ * ToolVersionPin names a file that pins the version of a tool and how to read it. Format is one of:
+ * "text" (the first word of the file, as in .nvmrc and .python-version), "go-mod" (the toolchain
+ * line, else the go line), "pyproject" (requires-python), "global-json" (sdk.version) and
+ * "rust-toolchain" (the channel).
+ */
+export interface ToolVersionPin {
+    /**
+     * File is the base name of the file, looked up at the workspace root and in the folders of the
+     * projects that use the tool.
+     */
+    file: string;
+    format: string;
+}
 /**
  * Toolchain is a runtime the pipeline must install, and how. Plugins asking for the same name share
  * one setup step (the first plugin's).
@@ -1297,6 +1485,14 @@ export interface UninstallParams {
     project: Project;
     packages: string[];
 }
+/**
+ * UnlinkParams asks a plugin to remove the dependency of Project on Library. Notes of the result
+ * say so when the manifest held no such dependency.
+ */
+export interface UnlinkParams {
+    project: Project;
+    library: Project;
+}
 /** VersionParams asks a plugin to record a new version in a project manifest. */
 export interface VersionParams {
     project: Project;
@@ -1433,6 +1629,21 @@ export interface ProtocolMethods {
         result: DependencyResult;
         capability: 'dependencies';
     };
+    /**
+     * Makes a project depend on a library of the same workspace and language, in the ecosystem's own
+     * form, then installs or locks as that needs.
+     */
+    'dependencies/link': {
+        params: LinkParams;
+        result: LinkResult;
+        capability: 'link';
+    };
+    /** Removes the dependency of a project on a library of the same workspace. */
+    'dependencies/unlink': {
+        params: UnlinkParams;
+        result: DependencyResult;
+        capability: 'link';
+    };
     /** Lists the dependencies the manifests of the plugin's projects declare. */
     'dependencies/declared': {
         params: DeclaredParams;

package/serve/index.d.ts

@@ -1,4 +1,4 @@
 export { serve, serveStreams } from './serve.use-case.ts';
 export { capabilitiesOf, implementsMethod } from './capabilities-of.algorithm.ts';
-export type { APISurfaceReader, Awaitable, Cancellable, CIContributor, ComponentLister, Contributor, DeclarationEditor, DependencyManager, Deriver, Discoverer, DoctorContributor, Generator, KindChanger, LatestReader, Plugin, PluginDescription, Publisher, RegistryReader, Remover, SmithPlugin, Versioner, } from './plugin.contract.ts';
+export type { APISurfaceReader, Awaitable, Cancellable, CIContributor, ComponentLister, Contributor, DeclarationEditor, DependencyManager, Deriver, Discoverer, DoctorContributor, Generator, KindChanger, LatestReader, Linker, Plugin, PluginDescription, Publisher, RegistryReader, Remover, SmithPlugin, Versioner, } from './plugin.contract.ts';
 export type { FrameSink, ServeStreams } from './protocol-streams.contract.ts';

package/serve/plugin-members.config.js

@@ -20,6 +20,8 @@ export const PLUGIN_MEMBERS = {
     'published': { member: 'published', requires: ['published'] },
     'dependencies/install': { member: 'install', requires: ['install', 'uninstall'] },
     'dependencies/uninstall': { member: 'uninstall', requires: ['install', 'uninstall'] },
+    'dependencies/link': { member: 'link', requires: ['link', 'unlink'] },
+    'dependencies/unlink': { member: 'unlink', requires: ['link', 'unlink'] },
     'dependencies/declared': { member: 'declared', requires: ['declared', 'rewrite'] },
     'dependencies/rewrite': { member: 'rewrite', requires: ['declared', 'rewrite'] },
     'dependencies/latest': { member: 'latest', requires: ['latest'] },

package/serve/plugin.contract.d.ts

@@ -1,4 +1,4 @@
-import type { DeriveParams, DeriveResult, APISurfaceParams, APISurfaceResult, ChangeKindParams, ChangeKindResult, CIParams, CIResult, ComponentsParams, ComponentsResult, ContributeParams, ContributeResult, DeclaredParams, DeclaredResult, DependencyResult, DiscoverParams, DiscoverResult, DoctorParams, DoctorResult, GenerateParams, GenerateResult, InitializeParams, InitializeResult, InstallParams, LatestParams, LatestResult, PublishedParams, PublishedResult, PublishParams, PublishResult, RemoveParams, RemoveResult, RewriteParams, UninstallParams, VersionParams, VersionResult } from '../protocol/index.ts';
+import type { DeriveParams, DeriveResult, APISurfaceParams, APISurfaceResult, ChangeKindParams, ChangeKindResult, CIParams, CIResult, ComponentsParams, ComponentsResult, ContributeParams, ContributeResult, DeclaredParams, DeclaredResult, DependencyResult, DiscoverParams, DiscoverResult, DoctorParams, DoctorResult, GenerateParams, GenerateResult, InitializeParams, InitializeResult, InstallParams, LatestParams, LatestResult, LinkParams, LinkResult, PublishedParams, PublishedResult, PublishParams, PublishResult, RemoveParams, RemoveResult, RewriteParams, UninstallParams, UnlinkParams, VersionParams, VersionResult } from '../protocol/index.ts';
 /** A result now or later: every method of a plugin may be `async`. */
 export type Awaitable<T> = T | Promise<T>;
 /** What a plugin says about itself. The serve loop fills in `protocolVersion` and `capabilities`. */
@@ -61,6 +61,11 @@ export interface DependencyManager {
     install: (params: InstallParams, signal: AbortSignal) => Awaitable<DependencyResult>;
     uninstall: (params: UninstallParams, signal: AbortSignal) => Awaitable<DependencyResult>;
 }
+/** `dependencies/link` and `dependencies/unlink`: both, or the capability is not advertised. */
+export interface Linker {
+    link: (params: LinkParams, signal: AbortSignal) => Awaitable<LinkResult>;
+    unlink: (params: UnlinkParams, signal: AbortSignal) => Awaitable<DependencyResult>;
+}
 /** `dependencies/declared` and `dependencies/rewrite`: both, or the capability is not advertised. */
 export interface DeclarationEditor {
     declared: (params: DeclaredParams, signal: AbortSignal) => Awaitable<DeclaredResult>;
@@ -93,4 +98,4 @@ export interface Cancellable {
  * from `cancellable`. How many requests it can work on at once is declared in
  * `describe`'s `concurrency`: omit it for one at a time, in order.
  */
-export type SmithPlugin = Plugin & Partial<Discoverer & Generator & Versioner & Publisher & RegistryReader & CIContributor & DoctorContributor & Remover & KindChanger & ComponentLister & Deriver & APISurfaceReader & DependencyManager & DeclarationEditor & LatestReader & Contributor & Cancellable>;
+export type SmithPlugin = Plugin & Partial<Discoverer & Generator & Versioner & Publisher & RegistryReader & CIContributor & DoctorContributor & Remover & KindChanger & ComponentLister & Deriver & APISurfaceReader & DependencyManager & Linker & DeclarationEditor & LatestReader & Contributor & Cancellable>;