@stringsync/splates 0.0.61 → 1.13.3

package/vendor/core/ship/version.d.ts

@@ -0,0 +1,9 @@
+/** How far a release moves the version. */
+export type Bump = "patch" | "minor" | "major";
+/**
+ * The newest of `versions`, or `undefined` when none is major.minor.patch.
+ * Anything else is skipped, as a tag nobody cut with a release would be.
+ */
+export declare function newest(versions: readonly string[]): string | undefined;
+/** Returns `version` moved by `type`. */
+export declare function bump(version: string, type: Bump): string;

package/vendor/core/ship/workspace/manifest-workspace.d.ts

@@ -0,0 +1,61 @@
+import { type Fs, type Ps } from "../../system/index.js";
+import type { Package, Workspace } from "./workspace";
+/**
+ * The package.json files a release reads and stamps. One version covers the
+ * whole workspace, and the root manifest is where it lives.
+ */
+/**
+ * What a `ManifestWorkspace` reads through and spawns `bun` with; the real
+ * filesystem and process by default.
+ */
+export interface ManifestWorkspaceOptions {
+    /**
+     * A top-level folder of the workspace root to narrow the workspace to: only
+     * its packages are listed and stamped, and its version is theirs, since the
+     * root manifest of a repository holding many projects has none. The root
+     * stays the repository's.
+     */
+    project?: string;
+    fs?: Fs;
+    ps?: Ps;
+}
+export declare class ManifestWorkspace implements Workspace {
+    /** The directory whose package.json declares the workspaces. */
+    readonly root: string;
+    private readonly fs;
+    private readonly ps;
+    private readonly project;
+    constructor(
+    /** The directory whose package.json declares the workspaces. */
+    root: string, opts?: ManifestWorkspaceOptions);
+    /**
+     * Finds the workspace `from` sits in, climbing until a manifest claims one.
+     * A repo holding a single package declares no workspaces, so when nothing
+     * above claims any, the nearest named manifest is a workspace of one.
+     */
+    static at(from: string, opts?: ManifestWorkspaceOptions): Promise<ManifestWorkspace>;
+    /** The version every package in the workspace, or its project, shares. */
+    version(): Promise<string>;
+    packages(): Promise<Package[]>;
+    /**
+     * Stamps `version` into every package, `bun.lock`, and the root manifest,
+     * in lockstep. The root goes last, because it is the version a
+     * release reads: stamping it first would leave a run that died partway
+     * reading as the version it never finished, and send the next one past it.
+     */
+    setVersion(version: string): Promise<void>;
+    private dirs;
+    /**
+     * The paths under `dir` that `segments` name, a `*` segment standing for
+     * every entry at that level, as in `packages/*` or `*\/packages/*`.
+     */
+    private expand;
+    /**
+     * Brings `bun.lock` up to the versions just stamped, as the next
+     * `bun install` would; left behind, that install dirties the tree the
+     * release just committed. bun writes it, so its format stays bun's business.
+     */
+    private lock;
+    private manifest;
+    private stamp;
+}

package/vendor/core/ship/workspace/workspace.d.ts

@@ -0,0 +1,29 @@
+/** One workspace package, as a release sees it. */
+export interface Package {
+    name: string;
+    /** The directory holding its package.json. */
+    dir: string;
+    /** Private packages still get the version stamp; they just never go out. */
+    private: boolean;
+    /**
+     * The workspace packages this one needs, which is what puts it later in the
+     * order a release builds and publishes in. Only siblings appear here:
+     * everything from outside the workspace is already on the registry.
+     */
+    dependencies: readonly string[];
+    /** The URL its manifest's `repository` names, if it names one. */
+    repository?: string;
+}
+/**
+ * The packages a release stamps and publishes. One version covers the whole
+ * workspace.
+ */
+export interface Workspace {
+    /** The directory the workspace is rooted at. */
+    readonly root: string;
+    /** The version every package in the workspace shares. */
+    version(): Promise<string>;
+    packages(): Promise<Package[]>;
+    /** Stamps `version` into every package, in lockstep. */
+    setVersion(version: string): Promise<void>;
+}

package/vendor/core/skills/index.d.ts

@@ -0,0 +1 @@
+export { ProjectSkills, type ProjectSkillsOptions, SKILLS_DIR, versionOf, } from "./project-skills";

package/vendor/core/skills/index.js

@@ -0,0 +1,77 @@
+// skills/project-skills.ts
+import { color } from "../log/index.js";
+var CLI = "skills@1";
+var SKILLS_DIR = ".agents/skills";
+function versionOf(md) {
+  const frontmatter = md.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? "";
+  return frontmatter.match(/^version:\s*(.+)$/m)?.[1]?.trim() ?? null;
+}
+
+class ProjectSkills {
+  root;
+  opts;
+  constructor(root, opts) {
+    this.root = root;
+    this.opts = opts;
+  }
+  path(name) {
+    return `${SKILLS_DIR}/${name}`;
+  }
+  async installed() {
+    const { fs } = this.opts;
+    const names = await fs.readdir(`${this.root}/${SKILLS_DIR}`).catch(() => []);
+    const present = [];
+    for (const name of names.toSorted()) {
+      if (await fs.exists(this.file(name))) {
+        present.push(name);
+      }
+    }
+    return present;
+  }
+  async version(name) {
+    return this.opts.fs.read(this.file(name)).then(versionOf).catch(() => null);
+  }
+  async linked(name) {
+    const { fs } = this.opts;
+    const dir = `${this.root}/${this.path(name)}`;
+    return await fs.isSymlink(dir) || await fs.isSymlink(this.file(name));
+  }
+  async add(names, version) {
+    const { ps, log } = this.opts;
+    const wanted = [];
+    for (const name of names) {
+      const installed = await this.version(name);
+      if (await this.linked(name)) {
+        log.info(`${this.path(name)} links to your own copy; leaving it`);
+      } else if (installed === version) {
+        log.info(`${this.path(name)} is already ${name} ${version}`);
+      } else {
+        wanted.push(name);
+        log.info(`${color.green("installing")} ${name} ${installed === null ? "" : `${installed} to `}${version}`);
+      }
+    }
+    if (wanted.length === 0) {
+      return;
+    }
+    const { exitCode } = await ps.spawn([
+      "bunx",
+      CLI,
+      "add",
+      `${this.opts.source}#v${version}`,
+      "--yes",
+      "--skill",
+      ...wanted
+    ], { cwd: this.root, env: { DISABLE_TELEMETRY: "1" } });
+    if (exitCode !== 0) {
+      throw new Error(`\`bunx ${CLI} add\` exited ${exitCode} installing ${wanted.join(", ")} ${version}`);
+    }
+  }
+  file(name) {
+    return `${this.root}/${this.path(name)}/SKILL.md`;
+  }
+}
+export {
+  ProjectSkills,
+  SKILLS_DIR,
+  versionOf
+};

package/vendor/core/skills/project-skills.d.ts

@@ -0,0 +1,53 @@
+import { type Logger } from "../log/index.js";
+import type { Fs, Ps } from "../system/index.js";
+/**
+ * Where a project keeps its skills. `skills` writes each one here, which
+ * Codex and most agents read, and links the directories of the rest, such as
+ * Claude Code's `.claude/skills`, to it.
+ */
+export declare const SKILLS_DIR = ".agents/skills";
+/** What `ProjectSkills` works through, and where its skills come from. */
+export interface ProjectSkillsOptions {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    /**
+     * The GitHub repository the skills come from, as `owner/name`: each
+     * release is a `v<version>` tag in it, and each skill a
+     * `skills/<name>/SKILL.md` there, which `bunx skills add` finds.
+     */
+    source: string;
+}
+/** The `version:` in a skill's frontmatter, or null when it has none. */
+export declare function versionOf(md: string): string | null;
+/**
+ * The agent skills a project has, those from one repository installed through
+ * the `skills` CLI from the tag of one of its releases, so a project's copy is
+ * always some release's, whichever tool put it there. A skill whose copy is a
+ * symbolic link is one someone keeps by hand, as a repository links its own
+ * to the source it edits, so it is left as it is.
+ */
+export declare class ProjectSkills {
+    /** The project's root, where `.agents/skills` is. */
+    private root;
+    private opts;
+    constructor(
+    /** The project's root, where `.agents/skills` is. */
+    root: string, opts: ProjectSkillsOptions);
+    /** Where the project keeps `name`, under its root. */
+    path(name: string): string;
+    /** The skills the project has, ours or not, in name order. */
+    installed(): Promise<string[]>;
+    /** The release the project's copy of `name` came from; null when it has none. */
+    version(name: string): Promise<string | null>;
+    /** Whether the project's copy of `name` is a link to one kept by hand. */
+    linked(name: string): Promise<boolean>;
+    /**
+     * Installs each of `names` as release `version` ships it, over whatever
+     * copy is there, or throws when `skills` fails. Skips a linked copy and
+     * one already at `version`, saying so, so running it again changes
+     * nothing and needs no network.
+     */
+    add(names: string[], version: string): Promise<void>;
+    private file;
+}

package/vendor/core/system/fs/fs.d.ts

@@ -0,0 +1,58 @@
+import type { Resource } from "../../disposable/index.js";
+/**
+ * Fs is the filesystem seam. Typically, this is assigned the variable name `fs`.
+ */
+export interface Fs {
+    exists(path: string): Promise<boolean>;
+    mkdir(path: string, opts?: MkdirOptions): Promise<void>;
+    read(path: string): Promise<string>;
+    write(path: string, data: string): Promise<void>;
+    /**
+     * Adds `data` to the end of the file, making it when it is missing, so a log
+     * grows without being rewritten whole.
+     */
+    append(path: string, data: string): Promise<void>;
+    readBytes(path: string): Promise<Uint8Array>;
+    writeBytes(path: string, data: Uint8Array): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    stat(path: string): Promise<StatResult>;
+    rm(path: string, opts?: RmOptions): Promise<void>;
+    /** Sets `path`'s permission bits, such as 0o600 for its owner alone. */
+    chmod(path: string, mode: number): Promise<void>;
+    /**
+     * Whether `path` is itself a symbolic link, rather than what one points
+     * at; false when nothing is there.
+     */
+    isSymlink(path: string): Promise<boolean>;
+    /**
+     * Calls `onChange` with the path that changed, whenever something in
+     * `path` does, until the watch is disposed: a write, a rename, a removal.
+     * Throws when `path` cannot be watched, as when it does not exist.
+     */
+    watch(path: string, onChange: (changed: string) => void, opts?: WatchOptions): Resource;
+}
+export interface MkdirOptions {
+    /**
+     * Defaults to true. Pass false for a create-or-throw: the failure is what
+     * makes `mkdir` usable as a mutex.
+     */
+    recursive?: boolean;
+}
+export interface WatchOptions {
+    /** Everything under `path` too, rather than its own entries alone. */
+    recursive?: boolean;
+}
+export interface RmOptions {
+    recursive?: boolean;
+    force?: boolean;
+}
+export interface StatResult {
+    isDirectory(): boolean;
+    /** Bytes on disk. Zero for a directory. */
+    size: number;
+    /** When it was last written, as epoch ms. */
+    mtimeMs: number;
+    /** Permission bits, such as 0o755; a file's executable bit is `mode & 0o111`. */
+    mode: number;
+}

package/vendor/core/system/fs/node-fs.d.ts

@@ -0,0 +1,18 @@
+import type { Resource } from "../../disposable/index.js";
+import type { Fs, MkdirOptions, RmOptions, StatResult, WatchOptions } from "./fs";
+export declare class NodeFs implements Fs {
+    exists(path: string): Promise<boolean>;
+    mkdir(path: string, opts?: MkdirOptions): Promise<void>;
+    read(path: string): Promise<string>;
+    write(path: string, data: string): Promise<void>;
+    append(path: string, data: string): Promise<void>;
+    readBytes(path: string): Promise<Uint8Array>;
+    writeBytes(path: string, data: Uint8Array): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    chmod(path: string, mode: number): Promise<void>;
+    stat(path: string): Promise<StatResult>;
+    rm(path: string, opts?: RmOptions): Promise<void>;
+    isSymlink(path: string): Promise<boolean>;
+    watch(path: string, onChange: (changed: string) => void, opts?: WatchOptions): Resource;
+}

package/vendor/core/system/glob/glob.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Glob is the path-matching seam. Typically, this is assigned the variable
+ * name `glob`.
+ *
+ * The pattern comes per call rather than per instance, so a caller holding a
+ * rule and a path never has to keep a compiled matcher alongside it. An
+ * implementation that does compile patterns caches them itself.
+ */
+export interface Glob {
+    matches(pattern: string, path: string): boolean;
+}

package/vendor/core/system/glob/node-glob.d.ts

@@ -0,0 +1,12 @@
+import type { Glob } from "./glob";
+/**
+ * A `Glob` that runs anywhere Node's `node:path` API does, Bun included.
+ *
+ * ```ts
+ * const glob = new NodeGlob();
+ * glob.matches("src/*.ts", "src/main.ts"); // true
+ * ```
+ */
+export declare class NodeGlob implements Glob {
+    matches(pattern: string, path: string): boolean;
+}

package/vendor/core/system/heavy/heavy-jobs.d.ts

@@ -0,0 +1,84 @@
+import type { Logger } from "../../log/index.js";
+import type { Fs } from "../fs/fs";
+import type { Lock } from "../lock/lock";
+import type { Ps } from "../ps/ps";
+/**
+ * A machine's heavy-job slots: `take` one before a test run or an install,
+ * and dispose of it after; `read` says who holds them and who waits. A holder
+ * that dies gives its slot back by dying. Every process that opens the same
+ * file shares one cap, whichever tool it runs in.
+ */
+export declare class HeavyJobs implements HeavyCap {
+    #private;
+    /**
+     * The slots kept in `dir`, as `heavy.json` beside the `heavy.lock` that
+     * guards it.
+     */
+    static under(dir: string, { fs, ps, log, cap, held, }: Pick<HeavyJobsOptions, "log" | "cap" | "held"> & {
+        fs: Fs;
+        ps: Ps;
+    }): HeavyJobs;
+    constructor(
+    /** The file the slots are kept in, or a test's own. */
+    path: string, opts: HeavyJobsOptions);
+    take({ what, task, }: {
+        what: string;
+        task?: string | null;
+    }): Promise<HeavySlot>;
+    read(): Promise<HeavyJobsReading>;
+}
+/** A job that holds, or waits for, one of the machine's slots. */
+export interface HeavyJob {
+    /** What it runs, as a waiter names it: "preMerge", "bun test". */
+    what: string;
+    /** The task it runs for, or null outside one. */
+    task: string | null;
+    /** The process that holds the slot, which frees it by exiting. */
+    pid: number;
+    /** When it started holding, or waiting. */
+    since: string;
+}
+/** Who holds the machine's slots, and who waits for one, first come first. */
+export interface HeavyJobsReading {
+    cap: number;
+    running: HeavyJob[];
+    waiting: HeavyJob[];
+}
+/** A slot taken, which its holder gives back when the job is done. */
+export interface HeavySlot extends AsyncDisposable {
+    /**
+     * What to add to the environment of what runs in it, so a heavy job it
+     * starts runs in this slot rather than waiting for another.
+     */
+    readonly env: Record<string, string>;
+}
+/**
+ * Caps the heavy jobs (test runs, installs, browser launches) running at
+ * once, so several agents testing together queue rather than pinning the CPU
+ * and running out of memory.
+ */
+export interface HeavyCap {
+    /** Waits for a free slot, saying what holds them all while it waits. */
+    take(job: {
+        what: string;
+        task?: string | null;
+    }): Promise<HeavySlot>;
+    read(): Promise<HeavyJobsReading>;
+}
+export interface HeavyJobsOptions {
+    fs: Fs;
+    /** Tells a holder that died from one still running, and whose job this is. */
+    ps: Pick<Ps, "pid" | "alive" | "env">;
+    /** Held while the file is read and rewritten, never while a job runs. */
+    lock: Lock;
+    log: Logger;
+    /** How many jobs run at once. */
+    cap: number;
+    /**
+     * The environment variable a slot sets for what runs in it; a job that
+     * finds it set already runs in its parent's slot, and takes none.
+     */
+    held: string;
+    /** The current time; a test passes its own. */
+    now?: () => Date;
+}

package/vendor/core/system/host-mapper/file-host-mapper.d.ts

@@ -0,0 +1,20 @@
+import { type Logger } from "../../log/index.js";
+import type { Fs } from "../fs/fs";
+import type { Ps } from "../ps/ps";
+import type { HostMapper } from "./host-mapper";
+/** What a `FileHostMapper` works through; the real ones by default. */
+export interface FileHostMapperOptions {
+    fs?: Fs;
+    ps?: Ps;
+    log?: Logger;
+}
+export declare class FileHostMapper implements HostMapper {
+    private readonly path;
+    private readonly fs;
+    private readonly ps;
+    private readonly log;
+    constructor(path: string, opts?: FileHostMapperOptions);
+    static default(opts?: FileHostMapperOptions): FileHostMapper;
+    map(hostname: string, ip: string): Promise<void>;
+    private writeHostFileUnix;
+}

package/vendor/core/system/host-mapper/host-mapper.d.ts

@@ -0,0 +1,11 @@
+/**
+ * HostMapper is the hostname-to-IP seam. Typically, this is assigned the
+ * variable name `hostMapper`.
+ *
+ * Mapping is idempotent: an implementation adds the entry, rewrites it when
+ * the IP has changed, and does nothing when it already matches. Writing the
+ * real hosts file needs elevated privileges, so `map` may prompt.
+ */
+export interface HostMapper {
+    map(hostname: string, ip: string): Promise<void>;
+}

package/vendor/core/system/host-mapper/noop-host-mapper.d.ts

@@ -0,0 +1,4 @@
+import type { HostMapper } from "./host-mapper";
+export declare class NoopHostMapper implements HostMapper {
+    map(): Promise<void>;
+}

package/vendor/core/system/index.d.ts

@@ -0,0 +1,25 @@
+export type { Fs, MkdirOptions, RmOptions, StatResult, WatchOptions, } from "./fs/fs";
+export { NodeFs } from "./fs/node-fs";
+export type { Glob } from "./glob/glob";
+export { NodeGlob } from "./glob/node-glob";
+export { type HeavyCap, type HeavyJob, HeavyJobs, type HeavyJobsOptions, type HeavyJobsReading, type HeavySlot, } from "./heavy/heavy-jobs";
+export { FileHostMapper, type FileHostMapperOptions, } from "./host-mapper/file-host-mapper";
+export type { HostMapper } from "./host-mapper/host-mapper";
+export { NoopHostMapper } from "./host-mapper/noop-host-mapper";
+export { DarwinIpProvider } from "./ip-provider/darwin-ip-provider";
+export type { IpProvider, IpProviderOptions, } from "./ip-provider/ip-provider";
+export { LinuxIpProvider } from "./ip-provider/linux-ip-provider";
+export { PlatformIpProvider } from "./ip-provider/platform-ip-provider";
+export { SequentialIpProvider } from "./ip-provider/sequential-ip-provider";
+export { StaticIpProvider } from "./ip-provider/static-ip-provider";
+export { Win32IpProvider } from "./ip-provider/win32-ip-provider";
+export { FileLock, type FileLockOptions } from "./lock/file-lock";
+export type { Lock } from "./lock/lock";
+export { MemoryLock } from "./lock/memory-lock";
+export { MAX_PORT, OpenPortProvider, type PortRange, type PortSpan, } from "./port-provider/open-port-provider";
+export type { PortProvider } from "./port-provider/port-provider";
+export type { ProcessLike } from "./process-like/process-like";
+export { NodePs, type NodePsOptions } from "./ps/node-ps";
+export type { Child, ListeningEntry, OutputWatcher, ProcessEntry, Ps, SpawnCaptureResult, SpawnOptions, SpawnResult, StartOptions, TerminalChild, TerminalOptions, } from "./ps/ps";
+export { type MakeUndumpableOptions, makeUndumpable, type Undumpable, } from "./undumpable";
+export { type WalkOptions, walk } from "./walk";