@opencode/schema 0.0.0-reserved → 2.0.1

package/dist/worktree-event.js

@@ -0,0 +1,18 @@
+export * as WorktreeEvent from "./worktree-event.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { Event } from "./event.js";
+export const Ready = Event.ephemeral({
+    type: "worktree.ready",
+    schema: {
+        name: Schema.String,
+        branch: optional(Schema.String),
+    },
+});
+export const Failed = Event.ephemeral({
+    type: "worktree.failed",
+    schema: {
+        message: Schema.String,
+    },
+});
+export const Definitions = Event.inventory(Ready, Failed);

package/dist/worktree.d.ts

@@ -0,0 +1,277 @@
+export * as Worktree from "./worktree.js";
+import { Schema } from "effect";
+export declare const StrategyID: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
+export type StrategyID = typeof StrategyID.Type;
+export declare const CreateInput: Schema.Struct<{
+    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Trim, "Worktree.StrategyID">>>, Schema.optionalKey<Schema.brand<Schema.Trim, "Worktree.StrategyID">>, never, never>;
+    readonly from: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Trim>>, Schema.optionalKey<Schema.Trim>, never, never>;
+    readonly directory: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {
+}
+export declare const RemoveInput: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly force: Schema.Boolean;
+}>;
+export interface RemoveInput extends Schema.Schema.Type<typeof RemoveInput> {
+}
+export declare const Info: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Directory: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export interface Directory extends Schema.Schema.Type<typeof Directory> {
+}
+export declare const ListEntry: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly type: Schema.Literals<readonly ["root", "worktree"]>;
+}>;
+export interface ListEntry extends Schema.Schema.Type<typeof ListEntry> {
+}
+declare const OperationError_base: Schema.Class<OperationError, Schema.TaggedStruct<"Worktree.OperationError", {
+    readonly message: Schema.String;
+    readonly forceRequired: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, import("effect/Cause").YieldableError>;
+export declare class OperationError extends OperationError_base {
+}
+export declare const List: Schema.$Array<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>>;
+export type List = typeof List.Type;
+export declare const Event: {
+    Updated: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"worktree.updated">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }> & {
+        type: "worktree.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    };
+    Resolved: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"worktree.resolved">;
+        readonly durable: Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
+        }>;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly previous: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly adopted: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            }>>>, Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            }>>, never, never>;
+        }>;
+    }> & {
+        type: "worktree.resolved";
+        durability: "durable";
+        durable: {
+            readonly version: number;
+            readonly aggregate: string;
+        };
+        data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly previous: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly adopted: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            }>>>, Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            }>>, never, never>;
+        }>;
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"worktree.updated">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }> & {
+        type: "worktree.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+        }>;
+    }, Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"worktree.resolved">;
+        readonly durable: Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
+        }>;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly previous: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly adopted: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            }>>>, Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            }>>, never, never>;
+        }>;
+    }> & {
+        type: "worktree.resolved";
+        durability: "durable";
+        durable: {
+            readonly version: number;
+            readonly aggregate: string;
+        };
+        data: Schema.Struct<{
+            readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly previous: Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            };
+            readonly adopted: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            }>>>, Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Project.ID"> & {
+                global: string & import("effect/Brand").Brand<"Project.ID">;
+            }>>, never, never>;
+        }>;
+    }];
+};
+export declare function adopt(session: {
+    readonly projectID: string;
+    readonly directory: string;
+    readonly workspaceID?: string;
+}, event: {
+    readonly projectID: string;
+    readonly directory: string;
+    readonly previous: string;
+    readonly adopted?: ReadonlyArray<string>;
+}): {
+    projectID: string;
+    subpath: string | undefined;
+} | undefined;

package/dist/worktree.js

@@ -0,0 +1,82 @@
+export * as Worktree from "./worktree.js";
+import { Schema } from "effect";
+import { durable, ephemeral, inventory } from "./event.js";
+import { AbsolutePath, optional } from "./schema.js";
+import { Project } from "./project.js";
+export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Schema.brand("Worktree.StrategyID"));
+export const CreateInput = Schema.Struct({
+    strategy: optional(StrategyID),
+    from: optional(AbsolutePath),
+    branch: optional(Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()))),
+    directory: optional(AbsolutePath).annotate({
+        description: "Parent directory for the new worktree. Uses the location's configuration, then defaults to the server's data directory under worktree/<first six project ID characters>.",
+    }),
+    name: optional(Schema.String),
+}).annotate({ identifier: "Worktree.CreateInput" });
+export const RemoveInput = Schema.Struct({
+    directory: AbsolutePath,
+    force: Schema.Boolean,
+}).annotate({ identifier: "Worktree.RemoveInput" });
+export const Info = Schema.Struct({
+    directory: AbsolutePath,
+}).annotate({ identifier: "Worktree.Info" });
+export const Directory = Schema.Struct({
+    directory: AbsolutePath,
+    strategy: optional(Schema.String),
+}).annotate({ identifier: "Worktree.Directory" });
+export const ListEntry = Schema.Struct({
+    directory: AbsolutePath,
+    type: Schema.Literals(["root", "worktree"]),
+}).annotate({ identifier: "Worktree.ListEntry" });
+export class OperationError extends Schema.TaggedError()("Worktree.OperationError", {
+    message: Schema.String,
+    forceRequired: optional(Schema.Boolean),
+}) {
+}
+export const List = Schema.Array(Directory).annotate({ identifier: "Worktree.List" });
+const Updated = ephemeral({
+    type: "worktree.updated",
+    schema: { projectID: Project.ID },
+});
+const Resolved = durable({
+    type: "worktree.resolved",
+    durable: { aggregate: "projectID", version: 1 },
+    schema: {
+        projectID: Project.ID,
+        directory: AbsolutePath,
+        previous: Project.ID,
+        adopted: optional(Schema.Array(Project.ID)),
+    },
+});
+export const Event = { Updated, Resolved, Definitions: inventory(Updated, Resolved) };
+export function adopt(session, event) {
+    if (session.workspaceID)
+        return;
+    if (session.projectID !== event.previous &&
+        session.projectID !== Project.ID.global &&
+        !event.adopted?.includes(session.projectID))
+        return;
+    if (session.projectID === event.projectID)
+        return;
+    const normalize = (value) => value
+        .replaceAll("\\", "/")
+        .split("/")
+        .reduce((result, segment) => {
+        if (!segment || segment === ".")
+            return result;
+        if (segment === "..")
+            return result.slice(0, result.lastIndexOf("/"));
+        return `${result}/${segment}`;
+    }, "");
+    const directory = normalize(session.directory);
+    const root = normalize(event.directory);
+    const windows = /^\/[a-z]:/i.test(root);
+    const key = windows ? directory.toLowerCase() : directory;
+    const parent = windows ? root.toLowerCase() : root;
+    if (key !== parent && !key.startsWith(parent + "/"))
+        return;
+    return {
+        projectID: event.projectID,
+        subpath: key === parent ? undefined : directory.slice(root.length + 1),
+    };
+}

package/package.json

@@ -1,15 +1,42 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/schema",
-  "version": "0.0.0-reserved",
-  "description": "OpenCode package bootstrap — not a functional release",
+  "version": "2.0.1",
+  "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git"
+    "url": "git+https://github.com/anomalyco/opencode.git",
+    "directory": "packages/schema"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "tag": "reserved"
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build.ts",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "1.1.0",
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.4.0",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1",
+    "typescript": "5.8.2"
   }
 }

package/README.md

@@ -1,5 +0,0 @@
-# @opencode/schema
-
-Bootstrap placeholder for the official [OpenCode](https://opencode.ai) release pipeline.
-
-This version contains no implementation or executable. Do not use it as a functional release.