@webappwiz/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jared Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# @webappwiz/cli
+
+Keeps a project in step with a webappwiz release.
+
+```bash
+bunx @webappwiz/cli update             # pin webappwiz deps, like bun update
+bunx @webappwiz/cli skills ls          # what there is, and what you have
+bunx @webappwiz/cli skills add arbor   # install an agent skill
+bunx @webappwiz/cli skills update      # refresh the ones already installed
+bunx @webappwiz/cli rules ls           # every rule there is
+bunx @webappwiz/cli judge .            # check a directory against them
+bunx @webappwiz/cli signoff            # does this change need a person?
+```
+
+## rules
+
+Every rule webappwiz judges itself by is named in [`rules.ts`](./rules.ts), as
+`JUDGE_RULES` and `SIGNOFF_RULES`, off the classes
+[`@webappwiz/rules`](../rules/rules) ships. There is no config file and no
+preset: a rule is in one of those lists or it does not exist.
+
+```
+ID                  RULE                       SET      LEVEL    FILES
+no-em-dashes        No em dashes               judge    error    **/*.ts
+one-class-per-file  One class per file         judge    error    **/*.ts
+visual-work-tested  Visual work is tested      signoff
+```
+
+`rules show <id>` prints one in full: its glob, its level, and the document an
+agent is handed verbatim.
+
+The `SET` column is which of the two lists a rule is in. `judge` rules are what
+`judge` checks files against, file by file. `signoff` rules have no glob and no
+level because they are about a change rather than a file: `signoff` weighs them,
+and what they answer is whether it needs a person rather than where the code is
+wrong.
+
+## signoff
+
+Weighs a change against the signoff rules and exits 1 with a reason when one of
+them wants a person to look before it merges. One agent call over the whole
+diff, since that is what these rules are about.
+
+```bash
+bunx @webappwiz/cli signoff                    # everything since main
+bunx @webappwiz/cli signoff --since HEAD~3     # measured against another ref
+bunx @webappwiz/cli signoff --print            # the rules, to apply yourself
+```
+
+`--print` is the cheapest signoff there is: the agent about to merge reads the
+rules and weighs its own change, spawning nothing. A project points its agent
+instructions at that rather than at a list of rule ids, which goes stale the
+next time a rule is added.
+
+## judge
+
+Runs the rules over a directory, one agent call per set of rules sharing a set
+of files.
+
+```bash
+bunx @webappwiz/cli judge . --agent haiku
+bunx @webappwiz/cli judge . --estimate        # what would this read, and cost
+bunx @webappwiz/cli judge . --print           # print the prompts, spawn nothing
+bunx @webappwiz/cli judge . --since main      # only what changed
+```
+
+Each rule's code half runs first, free, and only what it escalates reaches an
+agent. `--budget` caps what a run may read before it asks whether you meant it;
+`--estimate` answers that without having to guess a budget low enough to be
+refused. `--print`, `--estimate` and running are three things to do with one
+plan, so passing two of them is an error rather than one quietly winning. Code excuses itself from a rule with a `rule-ignore <id>: <reason>`
+comment above the line, or `rule-ignore-file <id>: <reason>` for the file.
+
+## update
+
+Walks a directory for every `package.json` (workspaces, nested apps, anything)
+and rewrites each webappwiz dependency to one version. They are released
+together, so a project running two of them at different versions is running a
+combination nobody tested.
+
+The default version is this package's own, which is the point of `bunx`: the
+release you invoke is the release you get. `--version` pins something else.
+`workspace:` ranges are left alone; inside a monorepo they already track each
+other.
+
+```bash
+bunx @webappwiz/cli update ./apps --version 1.4.0
+```
+
+## skills
+
+Puts the agent skills bundled with this package into `<dir>/.agents/skills/`.
+Each skill's frontmatter carries the version it came from, so a stale copy is
+visible rather than merely wrong.
+
+```bash
+bunx @webappwiz/cli skills ls ./project
+bunx @webappwiz/cli skills add arbor ./project
+bunx @webappwiz/cli skills update ./project
+```
+
+```
+SKILL  SHIPS  INSTALLED
+arbor  1.4.0  1.3.0
+other  1.4.0  -
+```
+
+`add` installs one skill by name. `update` refreshes the ones a project already
+has and never installs a new one: which skills a project uses is its own
+business, and a skill nobody chose should not arrive by way of an update. `ls`
+answers the one thing neither can: which version a project is actually holding.
+
+Both replace what is there; local edits to a synced skill do not survive, and
+are not meant to.

package/changed.d.ts

@@ -0,0 +1,30 @@
+import { type Ps } from "webappwiz/system";
+/**
+ * The files git says are new or changed in `dir` since `ref`, named the way a
+ * rule's glob is: relative to `dir`, so a run over one package of a repo sees
+ * its own paths rather than the repo's.
+ *
+ * Deletions are left out. A violation quotes the offending line from disk, so a
+ * file that is gone has nothing to read and nothing to report.
+ */
+export interface ChangedOptions {
+    /** What git is spawned through; the real process by default. */
+    ps?: Ps;
+}
+export declare function changed(dir: string, ref: string, opts?: ChangedOptions): Promise<Set<string>>;
+/**
+ * The change itself, as a patch: everything in `dir` that differs from `ref`,
+ * committed or not, and the paths of the files git has never been told about,
+ * which no diff reaches.
+ *
+ * The new files are named rather than shown because a reader of this patch is
+ * an agent with the working directory in front of it, and it can open them.
+ */
+export interface DiffOptions {
+    /** What git is spawned through; the real process by default. */
+    ps?: Ps;
+}
+export declare function diff(dir: string, ref: string, opts?: DiffOptions): Promise<{
+    patch: string;
+    added: string[];
+}>;

package/cost.d.ts

@@ -0,0 +1,45 @@
+import { type Fs } from "webappwiz/system";
+/** The agents an estimate can price, which is every one `--agent` accepts. */
+export declare const priced: () => string[];
+/**
+ * What those tokens cost to read on that agent, or undefined for an agent with
+ * no published price, which is any `--exec` command.
+ *
+ * A floor twice over: it counts input only, and only the input a plan can see.
+ */
+export declare function floor(agent: string, tokens: number): number | undefined;
+/**
+ * Dollars a single call costs beyond the files it was given, per agent.
+ *
+ * Everything the floor cannot see is charged per call, not per byte: the agent
+ * pays for its own system prompt every time it is spawned, and on this project
+ * that is most of a small call's bill. Measuring it per call is what lets a
+ * figure taken from a two-call run stand up to a fifteen-call one.
+ */
+export type Overheads = Record<string, number>;
+/**
+ * What past runs in `root` measured, empty until one has finished there. A
+ * missing or unreadable file is empty rather than an error: a calibration is a
+ * convenience, and losing it costs the caller a worse estimate, not a run.
+ */
+export interface OverheadsOptions {
+    /** What the record is read through; the real filesystem by default. */
+    fs?: Fs;
+}
+export declare function overheads(dir: string, opts?: OverheadsOptions): Promise<Overheads>;
+/**
+ * Records what a call on this agent costs over its floor, so the next
+ * `--estimate` has something better than one. Other agents are left alone,
+ * since each is a separate measurement.
+ */
+export interface CalibrateOptions {
+    /** What the record is written through; the real filesystem by default. */
+    fs?: Fs;
+}
+export declare function calibrate(dir: string, agent: string, call: number, opts?: CalibrateOptions): Promise<void>;
+/**
+ * What a plan costs on one agent: the price of the files it names, plus what
+ * every call charges on top. Undefined for an agent with no listed price, and
+ * the floor alone until a run has measured one.
+ */
+export declare function predict(agent: string, tokens: number, calls: number, measured: Overheads): number | undefined;

package/index-3k3rtw49.js

@@ -0,0 +1,128 @@
+import {
+  ask,
+  count,
+  diff,
+  divider,
+  mode,
+  overBudget,
+  tokens,
+  usd
+} from "./index-jbrs6gqt.js";
+
+// signoff.ts
+import {
+  agentCommand,
+  Harness,
+  prompt as reviewPrompt
+} from "@webappwiz/rules";
+import { ConsoleLogger, color } from "webappwiz/log";
+import { NodePs } from "webappwiz/system";
+import { SystemClock } from "webappwiz/time";
+class Signoff {
+  rules;
+  defaultAgent;
+  confirmer;
+  log;
+  ps;
+  clock;
+  constructor(rules, defaultAgent, opts = {}) {
+    this.rules = rules;
+    this.defaultAgent = defaultAgent;
+    this.confirmer = opts.confirmer ?? ask;
+    this.log = opts.log ?? new ConsoleLogger;
+    this.ps = opts.ps ?? new NodePs;
+    this.clock = opts.clock ?? new SystemClock;
+  }
+  async run(opts) {
+    if (mode(opts) === "print") {
+      this.print();
+      return;
+    }
+    const dir = opts.dir.replace(/\/+$/, "") || "/";
+    const { patch, added } = await diff(dir, opts.since, { ps: this.ps });
+    if (patch === "" && added.length === 0) {
+      this.log.info(`nothing has changed since ${opts.since}`);
+      return;
+    }
+    const agent = agentCommand(opts.exec === undefined ? { agent: opts.agent ?? this.defaultAgent } : opts);
+    const review = this.review(patch, added, opts.since);
+    const predicted = tokens(review.bytes ?? 0);
+    this.log.info(`weighing ${opts.since}..working tree against ` + `${count(this.rules.length, "rule")}, reading ` + `${predicted}+ tokens with ${agent.label}`);
+    if (predicted > opts.budget) {
+      this.log.info(overBudget(predicted, opts.budget));
+      if (!await this.confirmer.confirm("Run anyway?")) {
+        throw new Error("over budget");
+      }
+    }
+    this.say(await this.judge(review, agent, dir));
+  }
+  async judge(review, agent, dir) {
+    const harness = new Harness({
+      log: this.log,
+      ps: this.ps,
+      clock: this.clock
+    });
+    harness.events.on("finished", ({ took, cost }) => {
+      const spent = cost === undefined ? "" : `  ${usd(cost)}`;
+      this.log.info(color.gray(`read in ${took.human()}${spent}`));
+    });
+    return await harness.run([review], agent, { cwd: dir });
+  }
+  say(findings) {
+    if (findings.length === 0) {
+      this.log.info(color.green("✓ nothing in this change needs a person"));
+      return;
+    }
+    for (const finding of findings) {
+      const where = finding.file === undefined ? "" : `${color.bold(finding.file + (finding.line === undefined ? "" : `:${finding.line}`))}  `;
+      this.log.info(`  ${where}${finding.message} ${color.gray(`(${finding.rule})`)}`);
+    }
+    throw new Error(`${count(findings.length, "reason")} to escalate rather than merge`);
+  }
+  review(patch, added, ref) {
+    const draft = {
+      rules: this.rules,
+      label: "signoff",
+      context: [
+        `The change, as \`git diff ${ref}\` prints it:`,
+        `\`\`\`diff
+${patch}
+\`\`\``,
+        ...added.length === 0 ? [] : [
+          "These files are new and are in no diff yet. Read each one from " + "your working directory:",
+          added.map((file) => `- ${file}`).join(`
+`)
+        ]
+      ].join(`
+
+`),
+      instructions: WEIGHING
+    };
+    return { ...draft, bytes: Buffer.byteLength(reviewPrompt(draft)) };
+  }
+  print() {
+    if (this.rules.length === 0) {
+      this.log.info("no signoff rules");
+      return;
+    }
+    this.log.info("Weigh your change against each rule below. Anything that needs " + "review goes to a person instead of trunk.");
+    for (const rule of this.rules) {
+      this.log.info(`
+${divider(rule.id)}
+`);
+      this.log.info(rule.document.trim());
+    }
+    this.log.info(`
+${divider()}`);
+  }
+}
+var WEIGHING = [
+  "These rules decide one thing: whether this change can merge on its own, " + "or needs a person to look at it first.",
+  "",
+  "Each rule's `Ships` section is what merges with nobody looking, and its " + "`Needs review` section is what does not. Report a violation only for " + "what the `Needs review` side covers, and only where the change " + "actually does it.",
+  "",
+  "These rules are about the change as a whole, so leave `file` and `line` " + "out unless one place in the change is the whole of the answer."
+].join(`
+`);
+
+export { Signoff };

package/index-8jpb8xae.js

@@ -0,0 +1,44 @@
+// rules.ts
+import { defineRules } from "@webappwiz/rules";
+import {
+  ClassesOverFunctionExports,
+  CommentsSayWhyNotWhat,
+  DevServersFindAPort,
+  DocCommentsAddressUsers,
+  FakesOverMocks,
+  NamedOptionsLast,
+  NoEmDashes,
+  ObjectsOverCallbacks,
+  OneClassPerFile,
+  OneDirPerInterface,
+  ParametersDeclareFields,
+  ReactiveOverUseState,
+  ResourcesAreDisposable,
+  SimpleTestSetup,
+  TestsNotWeakened,
+  VisualWorkTested
+} from "@webappwiz/rules/catalog";
+var JUDGE_RULES = defineRules({
+  rules: [
+    new NoEmDashes,
+    new OneClassPerFile,
+    new ParametersDeclareFields,
+    new ClassesOverFunctionExports,
+    new ObjectsOverCallbacks,
+    new NamedOptionsLast,
+    new SimpleTestSetup,
+    new FakesOverMocks,
+    new CommentsSayWhyNotWhat,
+    new DocCommentsAddressUsers,
+    new OneDirPerInterface,
+    new DevServersFindAPort,
+    new ReactiveOverUseState,
+    new ResourcesAreDisposable
+  ]
+});
+var SIGNOFF_RULES = [
+  new TestsNotWeakened,
+  new VisualWorkTested
+];
+
+export { JUDGE_RULES, SIGNOFF_RULES };

package/index-g2q5rg7s.js

@@ -0,0 +1,229 @@
+import {
+  table
+} from "./index-jbrs6gqt.js";
+// package.json
+var version = "0.0.1";
+
+// skills/add.ts
+import { ConsoleLogger } from "webappwiz/log";
+import { NodeFs } from "webappwiz/system";
+
+// skills/skill.ts
+import { dirname } from "node:path";
+
+// templates/arbor.skill.md
+var arbor_skill_default = `---
+name: arbor
+description: Use the @webappwiz/arbor CLI to land your work on trunk, or a base branch given as an argument, from an isolated git worktree without pull requests. Read this before making any code change in an arbor repository, since it decides where the work happens, and whenever you need to add, claim, merge, remove, list, show, locate, or escalate a task.
+argument-hint: "[base-branch]"
+version: 0.0.0
+---
+
+# Using arbor
+
+\`arbor\` runs many agents on one repo, each in its own git worktree, landing on
+trunk without pull requests. Run it with \`bunx @webappwiz/arbor <command>\` (or
+\`arbor\` if on PATH). \`arbor --help\` explains the commands; this file covers
+only what the CLI cannot tell you.
+
+**Rule:** never use raw git for state transitions arbor covers. Every landing
+goes through \`arbor merge\`. The only exception is finishing an in-progress
+rebase (\`git add\`, \`git rebase --continue\`), then merging again.
+
+A failed command prints \`{reason}\` JSON on stdout and instructions on stderr:
+do what stderr says. The one case to memorize is exit 4 \`lease_lost\`: stop,
+do not retry, another agent owns the tree.
+
+## Before you start
+
+Other agents may already be working. Before creating anything, list the files
+you expect to touch, then \`arbor ls\`, and for each task in flight compare with
+its changed files:
+\`git -C "$(arbor path <task>)" diff --name-only main...task/<task>\`
+(\`arbor show <task>\` for its plan; neither takes its lease).
+
+If nothing overlaps, carry on. If something does, wait for it to land rather
+than buying a rebase conflict: say one line about what you are waiting on,
+then re-check periodically. A status is only true for the moment you read it,
+so re-run \`arbor ls\` every time you are about to repeat one. Act on what it
+becomes:
+
+- gone from \`arbor ls\`: it landed. Redo the overlap check (trunk moved) and
+  carry on.
+- \`escalated\`: your work is blocked on a person too. Tell the human what it
+  is blocked on and wait.
+- \`orphaned\`, \`stray\`, \`unrecorded\` or \`unknown\` with nobody driving it: that
+  tree is broken. Say so and ask. (A tree mid-merge can read as \`orphaned\`
+  for a moment, so trust a broken status only if it survives a second look.)
+- still \`working\` or \`merging\` after however long the human would tolerate
+  hearing nothing: offer the choice of waiting longer, working alongside, or
+  picking up something else, and say what you have not started.
+
+A \`stale\` lease on a \`working\` task is normal (arbor only heartbeats while a
+command runs): when waiting, watch a task's status, never its lease.
+
+## Workflow
+
+1. \`arbor add <task>\`, or \`arbor claim <task>\` to resume one. When this skill
+   is invoked with a branch argument (\`/arbor feature/auth\`), or the user
+   names the branch the work should land on, pass it as \`--base\` to every
+   task you create for that request. Otherwise omit \`--base\`; never guess a
+   base from the currently checked-out branch.
+2. Fill in the \`ARBOR.md\` stub \`add\` wrote at the worktree root (see below).
+3. Do the work; commit with git (arbor never commits for you).
+4. \`arbor merge\`. On failure, do what stderr says and merge again.
+
+A successful merge deletes the worktree, and your working directory with it:
+\`cd\` to the main tree (merge prints its path) before running anything else.
+Then report it:
+
+\`\`\`\`markdown
+### ✅ Merged \`<task>\` onto \`<base>\`
+
+One sentence blending what the task set out to do with what actually changed.
+\`\`\`\`
+
+✅ for a merge, ❌ for a task you \`arbor rm\`ed instead. Anything else worth
+saying goes after this block, not instead of it.
+
+## ARBOR.md
+
+Your session can die at any moment; \`ARBOR.md\` is what lets a stranger
+\`arbor claim\` the task and continue. Fill in \`## Goal\` (one or two lines on
+what done means) and list every step you can foresee under \`## Next\` as
+\`- [ ]\` items, roughly one commit each. Move items to \`## Done\` as you finish
+them: those checkboxes are the only progress the task reports. Decisions,
+dead ends and how to verify go under \`## Notes\`. Update it as you go; a stale
+plan is worse than none.
+
+\`arbor show <task>\` prints the file and every way it departs from the
+expected shape; run it on your own task after writing the file. \`add\` excludes
+\`ARBOR.md\` from git for you: never commit it, and never mention it in a commit
+message.
+
+## Committing
+
+Plain, human-style commit messages with **no attribution**: no
+\`Co-authored-by:\` trailers, no "Generated with", no agent or model names, no
+\`--author\` overrides. Commit as often as it helps you; a task usually takes
+fewer than 5 commits, and wanting many more means the task wants splitting,
+not squashing.
+
+## Escalation
+
+Merge only work you verified yourself. Escalate instead when verification
+needs a person: external services, destructive migrations, anything tests
+cannot confirm. And if the user asked to see the work before it lands,
+escalate regardless.
+
+1. \`arbor escalate <reason>\`.
+2. Under \`## Blocked\` in \`ARBOR.md\`, state what needs verifying, ending in a
+   question a yes/no or a sentence can answer.
+3. Leave something the human can look at and print its **absolute path**
+   (start from \`arbor path <task>\`). For anything visual or UX, that means a
+   screenshot; if producing one is expensive or has side effects, ask before
+   starting and say what it will cost.
+
+If you claim a tree whose \`## Blocked\` question is unanswered, do not resume
+or merge: ask the user and wait for the answer.
+`;
+
+// skills/skill.ts
+var bundled = { arbor: arbor_skill_default };
+function versionOf(md) {
+  const frontmatter = md.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? "";
+  return frontmatter.match(/^version:\s*(.+)$/m)?.[1]?.trim() ?? null;
+}
+function available(skills) {
+  return Object.entries(skills).toSorted(([left], [right]) => left.localeCompare(right));
+}
+async function copy(name, doc, dir, opts) {
+  const target = `${dir}/.agents/skills/${name}/SKILL.md`;
+  await opts.fs.mkdir(dirname(target));
+  await opts.fs.write(target, doc);
+  opts.log.info(`wrote ${target}`);
+}
+
+// skills/add.ts
+async function add(opts) {
+  const log = opts.log ?? new ConsoleLogger;
+  const fs = opts.fs ?? new NodeFs;
+  const skills = opts.skills ?? bundled;
+  const doc = skills[opts.skill];
+  if (doc === undefined) {
+    const have = available(skills).map(([name]) => name);
+    throw new Error(`no such skill: ${opts.skill} (have ${have.join(", ")})`);
+  }
+  await copy(opts.skill, doc, opts.dir, { log, fs });
+}
+
+// skills/ls.ts
+import { ConsoleLogger as ConsoleLogger2, color } from "webappwiz/log";
+import { NodeFs as NodeFs2 } from "webappwiz/system";
+async function ls(opts) {
+  const log = opts.log ?? new ConsoleLogger2;
+  const fs = opts.fs ?? new NodeFs2;
+  const skills = opts.skills ?? bundled;
+  const rows = [["skill", "ships", "installed"].map(color.dim)];
+  let stale = 0;
+  for (const [name, doc] of available(skills)) {
+    const ships = versionOf(doc) ?? "?";
+    const installed = await fs.read(`${opts.dir}/.agents/skills/${name}/SKILL.md`).then(versionOf).catch(() => null);
+    if (installed !== null && installed !== ships) {
+      stale++;
+    }
+    rows.push([name, ships, installed ?? "-"]);
+  }
+  const lines = table(rows);
+  if (stale > 0) {
+    lines.push("", `${stale} out of date: run \`skills update\``);
+  }
+  log.info(lines.join(`
+`));
+}
+
+// skills/update.ts
+import { ConsoleLogger as ConsoleLogger3 } from "webappwiz/log";
+import { NodeFs as NodeFs3 } from "webappwiz/system";
+async function update(opts) {
+  const log = opts.log ?? new ConsoleLogger3;
+  const fs = opts.fs ?? new NodeFs3;
+  const installed = await fs.readdir(`${opts.dir}/.agents/skills`).catch(() => []);
+  const skills = opts.skills ?? bundled;
+  const ours = available(skills).filter(([name]) => installed.includes(name));
+  if (ours.length === 0) {
+    log.info(`no webappwiz skills in ${opts.dir}: add one with \`skills add\``);
+    return;
+  }
+  for (const [name, doc] of ours) {
+    await copy(name, doc, opts.dir, { log, fs });
+  }
+}
+
+// update.ts
+import { basename } from "node:path";
+import { ConsoleLogger as ConsoleLogger4 } from "webappwiz/log";
+import { NodeFs as NodeFs4, walk } from "webappwiz/system";
+var DEPENDENCY = /("(?:webappwiz|@webappwiz\/[^"]+)"\s*:\s*")(?!workspace:)[^"]*(")/g;
+async function update2(opts) {
+  const log = opts.log ?? new ConsoleLogger4;
+  const fs = opts.fs ?? new NodeFs4;
+  let count = 0;
+  for await (const path of walk(opts.dir, { fs })) {
+    if (basename(path) !== "package.json") {
+      continue;
+    }
+    const before = await fs.read(path);
+    const after = before.replace(DEPENDENCY, `$1${opts.version}$2`);
+    if (after === before) {
+      continue;
+    }
+    await fs.write(path, after);
+    log.info(`updated ${path}`);
+    count++;
+  }
+  log.info(`${count} package.json pinned to ${opts.version}`);
+  await update({ dir: opts.dir, log, fs, skills: opts.skills });
+}
+
+export { version, add, ls, update, update2 as update1 };