@codeworksh/plugin 0.1.0-dev.20261007133154 → 0.2.0-dev.20261012155220

package/{event-BnLveFBB.d.mts → event-6sTQ_4bq.d.mts}

@@ -18,6 +18,8 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
     options?: Record<string, any>;
   };
   model: string;
+  thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+  providerThinkingLevel?: string;
   usage: {
     input: number;
     output: number;
@@ -147,13 +149,26 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
     completed: number;
   };
   parts: ({
+    type: "text";
+    text: string;
+    textSignature?: string;
+  } | {
+    type: "image";
+    data: string;
+    mimeType: string;
+  } | {
+    type: "thinking";
+    thinking: string;
+    thinkingSignature?: string;
+    redacted?: boolean;
+  } | {
     addedToolNames?: string[];
     arguments: Record<string, any>;
     callID: string;
     name: string;
     namespace?: string;
-    result: {
-      content: ({
+    partial?: {
+      content?: ({
         type: "text";
         text: string;
         textSignature?: string;
@@ -163,9 +178,8 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
         mimeType: string;
       })[];
       details?: any;
-      isError: false;
     };
-    status: "completed";
+    status: "running";
     thoughtSignature?: string;
     time: {
       start: number;
@@ -189,9 +203,9 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
         mimeType: string;
       })[];
       details?: any;
-      isError: true;
+      isError: false;
     };
-    status: "error";
+    status: "completed";
     thoughtSignature?: string;
     time: {
       start: number;
@@ -217,7 +231,7 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
       details?: any;
       isError: true;
     };
-    status: "skipped";
+    status: "error";
     thoughtSignature?: string;
     time: {
       start: number;
@@ -243,34 +257,21 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
       details?: any;
       isError: true;
     };
-    status: "aborted";
+    status: "skipped";
     thoughtSignature?: string;
     time: {
       start: number;
       end: number;
     };
     type: "toolCall";
-  } | {
-    type: "text";
-    text: string;
-    textSignature?: string;
-  } | {
-    type: "image";
-    data: string;
-    mimeType: string;
-  } | {
-    type: "thinking";
-    thinking: string;
-    thinkingSignature?: string;
-    redacted?: boolean;
   } | {
     addedToolNames?: string[];
     arguments: Record<string, any>;
     callID: string;
     name: string;
     namespace?: string;
-    partial?: {
-      content?: ({
+    result: {
+      content: ({
         type: "text";
         text: string;
         textSignature?: string;
@@ -280,8 +281,9 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
         mimeType: string;
       })[];
       details?: any;
+      isError: true;
     };
-    status: "running";
+    status: "aborted";
     thoughtSignature?: string;
     time: {
       start: number;
@@ -318,6 +320,8 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
     options?: Record<string, any>;
   };
   model: string;
+  thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+  providerThinkingLevel?: string;
   usage: {
     input: number;
     output: number;
@@ -447,13 +451,26 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
     completed: number;
   };
   parts: ({
+    type: "text";
+    text: string;
+    textSignature?: string;
+  } | {
+    type: "image";
+    data: string;
+    mimeType: string;
+  } | {
+    type: "thinking";
+    thinking: string;
+    thinkingSignature?: string;
+    redacted?: boolean;
+  } | {
     addedToolNames?: string[];
     arguments: Record<string, any>;
     callID: string;
     name: string;
     namespace?: string;
-    result: {
-      content: ({
+    partial?: {
+      content?: ({
         type: "text";
         text: string;
         textSignature?: string;
@@ -463,9 +480,8 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
         mimeType: string;
       })[];
       details?: any;
-      isError: false;
     };
-    status: "completed";
+    status: "running";
     thoughtSignature?: string;
     time: {
       start: number;
@@ -489,9 +505,9 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
         mimeType: string;
       })[];
       details?: any;
-      isError: true;
+      isError: false;
     };
-    status: "error";
+    status: "completed";
     thoughtSignature?: string;
     time: {
       start: number;
@@ -517,7 +533,7 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
       details?: any;
       isError: true;
     };
-    status: "skipped";
+    status: "error";
     thoughtSignature?: string;
     time: {
       start: number;
@@ -543,34 +559,21 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
       details?: any;
       isError: true;
     };
-    status: "aborted";
+    status: "skipped";
     thoughtSignature?: string;
     time: {
       start: number;
       end: number;
     };
     type: "toolCall";
-  } | {
-    type: "text";
-    text: string;
-    textSignature?: string;
-  } | {
-    type: "image";
-    data: string;
-    mimeType: string;
-  } | {
-    type: "thinking";
-    thinking: string;
-    thinkingSignature?: string;
-    redacted?: boolean;
   } | {
     addedToolNames?: string[];
     arguments: Record<string, any>;
     callID: string;
     name: string;
     namespace?: string;
-    partial?: {
-      content?: ({
+    result: {
+      content: ({
         type: "text";
         text: string;
         textSignature?: string;
@@ -580,8 +583,9 @@ declare const AikitAssistantMessage: Schema.decodeTo<Schema.declare<{
         mimeType: string;
       })[];
       details?: any;
+      isError: true;
     };
-    status: "running";
+    status: "aborted";
     thoughtSignature?: string;
     time: {
       start: number;
@@ -892,4 +896,4 @@ declare function durable<const Definitions extends ReadonlyArray<Definition>>(de
 declare function latest(definitions: ReadonlyArray<Definition>): ReadonlyMap<string, Definition<string, Schema.Codec<unknown, unknown, never, never>>>;
 //#endregion
 export { ID as a, define as c, inventory as d, latest as f, Definition as i, durable as l, AikitToolCallTerminalPart as n, Payload as o, versionedType as p, Data as r, PublishOptions as s, AikitAssistantMessage as t, event_d_exports as u };
-//# sourceMappingURL=event-BnLveFBB.d.mts.map
+//# sourceMappingURL=event-6sTQ_4bq.d.mts.map

package/event.d.mts

@@ -1,2 +1,2 @@
-import { a as ID, c as define, d as inventory, f as latest, i as Definition, l as durable, n as AikitToolCallTerminalPart, o as Payload, p as versionedType, r as Data, s as PublishOptions, t as AikitAssistantMessage, u as event_d_exports } from "./event-BnLveFBB.mjs";
+import { a as ID, c as define, d as inventory, f as latest, i as Definition, l as durable, n as AikitToolCallTerminalPart, o as Payload, p as versionedType, r as Data, s as PublishOptions, t as AikitAssistantMessage, u as event_d_exports } from "./event-6sTQ_4bq.mjs";
 export { AikitAssistantMessage, AikitToolCallTerminalPart, Data, Definition, event_d_exports as EventSchema, ID, Payload, PublishOptions, define, durable, inventory, latest, versionedType };

package/filesystem-CuGE9poU.d.mts

@@ -0,0 +1,268 @@
+import { Context, Effect, Schema } from "effect";
+declare namespace scan_d_exports {
+  export { LineScan, LineScanOptions, LineScanner, ShellRun, parse, script, scriptArgs, validate, viaShell };
+}
+/**
+ * Bounded line reads: one pass over a file that returns a window of its lines
+ * without ever holding more than that window.
+ *
+ * Lines are the file split on `\n`, where a trailing newline ends the last line
+ * rather than starting an empty one: `""` has 0 lines, `"a"` and `"a\n"` have 1,
+ * `"a\n\n"` has 2. A UTF-8 byte-order mark at the start of the file is not part
+ * of the first line. Line lengths are in bytes.
+ *
+ * Two implementations share these rules, and a backend uses whichever fits:
+ * {@link LineScanner} over a byte stream, or {@link script} run inside the
+ * sandbox so only the window crosses the network.
+ */
+interface LineScanOptions {
+  /** First selected line, 0-based. */
+  readonly startLine: number;
+  /** End of the selection, exclusive; absent selects to the end of the file. */
+  readonly endLine?: number;
+  /** Most UTF-8 bytes of selected text to return; selection stops at the last whole line that fits. */
+  readonly maxBytes: number;
+}
+interface LineScan {
+  /**
+   * The selected whole lines that fit `maxBytes`, joined with `\n`. Invalid
+   * UTF-8 becomes U+FFFD; how many per bad sequence depends on the decoder of
+   * the backend's transport.
+   */
+  readonly text: string;
+  /** Lines in {@link text}. */
+  readonly lines: number;
+  /** Lines in the whole file. */
+  readonly totalLines: number;
+  /** Bytes in the whole file, byte-order mark included. */
+  readonly totalBytes: number;
+  /**
+   * Bytes of the first selected line, 0 when nothing is selected. Larger than
+   * `maxBytes` exactly when that line alone does not fit, and `text` is empty.
+   */
+  readonly firstLineBytes: number;
+}
+/** A defect, not a file error: callers derive these from already-validated input. */
+declare const validate: (options: LineScanOptions) => void;
+/**
+ * Computes a {@link LineScan} from a file's bytes fed in order, in memory
+ * bounded by `maxBytes`. Feed at most the file size observed when the read
+ * started, so a file that keeps growing cannot keep the scan going.
+ */
+declare class LineScanner {
+  private readonly start;
+  private readonly end;
+  private readonly maxBytes;
+  private readonly decoder;
+  /** The first bytes, held until it is known whether they are a byte-order mark. */
+  private head;
+  private totalBytes;
+  private line;
+  private lineLength;
+  private lineOpen;
+  /** The current line's bytes, kept only while it is selected and could still fit. */
+  private pieces;
+  private selected;
+  private selectedBytes;
+  private firstLineBytes;
+  private full;
+  constructor(options: LineScanOptions);
+  push(chunk: Uint8Array): void;
+  finish(): LineScan;
+  private releaseHead;
+  private scan;
+  private isSelected;
+  private append;
+  private endLine;
+}
+/**
+ * {@link LineScanner} as a POSIX shell script, for backends that only expose a
+ * process API. Run as `sh -c <script> _ <path> <startLine> <endLine|-1> <maxBytes>`.
+ * The whole file is read inside the sandbox; only the window is printed, after a
+ * header line `<lines> <totalLines> <totalBytes> <firstLineBytes>` and before a
+ * closing `|` — see {@link parse}.
+ * Exits 2 when the path does not exist.
+ */
+declare const script: string;
+/** Arguments for {@link script} after the path. */
+declare const scriptArgs: (options: LineScanOptions) => Array<string>;
+/** Read {@link script}'s output. */
+declare const parse: (stdout: string) => LineScan;
+interface ShellRun {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr?: string;
+}
+/**
+ * `Provider.scanLines` for a backend that runs an argument vector and collects
+ * its output: runs {@link script} in the sandbox and reads the result. A missing
+ * path rejects with `ENOENT`, the shape `isNotFoundError` recognises.
+ */
+declare const viaShell: (run: (argv: ReadonlyArray<string>) => Promise<ShellRun>) => (path: string, options: LineScanOptions) => Promise<LineScan>;
+declare namespace filesystem_d_exports {
+  export { FileStat, FileSystemError, Interface, LineScan, LineScanOptions, OperationUnsupportedError, Provider, RmOptions, filesystem_d_exports as SandboxFileSystem, scan_d_exports as Scan, Service, fromProvider, isNotFoundError, readBytesScript, readBytesViaShell, realpathScripts, validateRmOptions, withCwd };
+}
+declare const OperationUnsupportedError_base: Schema.Class<OperationUnsupportedError, Schema.TaggedStruct<"OperationUnsupportedError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The runtime filesystem contract, independent of any backend.
+ *
+ * Two surfaces, deliberately:
+ * - {@link Provider} is what a backend implements — plain promises that reject,
+ *   matching every SDK we wrap.
+ * - {@link Interface} is what the harness consumes — Effect with a typed error
+ *   channel and tracing spans. {@link fromProvider} bridges the two exactly
+ *   once, so no consumer ever writes `Effect.tryPromise` against a filesystem.
+ *
+ * Implementations:
+ * - Local:
+ * implement it over a VFS (`./local`);
+ * local filesystem use OS primitives; hence have broader filesytem capabilities.
+ *
+ * - Remote:
+ * implement it over a provider (`./remote`).
+ * remote filesytems depends on the interface provided by the remote provider; hence can have limited filesytem capabilities.
+ *
+ * `isFile`/`isDirectory` are required booleans; size, mtime, and isSymbolicLink are omitted when the
+ * backend cannot report them — never fabricated.
+ *
+ * **Paths are POSIX, and the harness is Unix-only (for now!).** Every path uses `/`
+ * separators on both the host and inside a sandbox — Windows is not supported,
+ * so no translation layer exists. Consumers must use the shared Effect POSIX
+ * path implementation, never the platform default, or a host running the harness would
+ * impose its own flavour on a remote sandbox's paths. Relative paths resolve
+ * against the backend's configured `cwd`.
+ */
+declare class OperationUnsupportedError extends OperationUnsupportedError_base {}
+declare const FileSystemError_base: Schema.Class<FileSystemError, Schema.TaggedStruct<"SandboxFileSystemError", {
+  readonly method: Schema.String;
+  readonly path: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** A backend operation failed. `cause` carries the provider's own rejection. */
+declare class FileSystemError extends FileSystemError_base {}
+interface FileStat {
+  readonly isFile: boolean;
+  readonly isDirectory: boolean;
+  readonly isSymbolicLink?: boolean;
+  readonly size?: number;
+  readonly mtime?: Date;
+}
+interface RmOptions {
+  readonly recursive?: boolean;
+  readonly force?: boolean;
+}
+/** Whether a provider failure means the path itself is definitively absent. */
+declare const isNotFoundError: (cause: unknown) => boolean;
+/**
+ * Shell forms of `realpath` for backends that only expose a process API. Run as
+ * `sh -c <script> _ <path>`, trying each in turn. `realpath -e` (coreutils)
+ * resolves every component, a symlinked file included, and fails on a missing
+ * path. Where it is absent, `pwd -P` is the portable primitive: directories
+ * resolve directly, anything else resolves its parent and keeps the final name
+ * as given — so a symlinked *file* stays unresolved there.
+ */
+declare const realpathScripts: readonly ['realpath -e -- "$1"', 'cd -- "$1" && pwd -P', 'cd -- "$(dirname -- "$1")" && printf \'%s/%s\' "$(pwd -P)" "$(basename -- "$1")"'];
+/**
+ * Shell form of `readBytes` for backends that only expose a process API. Run as
+ * `sh -c <script> _ <path> <offset + 1> <length>`; prints the bytes as base64,
+ * so binary content survives a transport that decodes stdout as text. Exits 2
+ * when the path does not exist, 3 when it cannot be opened.
+ */
+declare const readBytesScript: string;
+/**
+ * `Provider.readBytes` for a backend that runs an argument vector and collects
+ * its output. A missing path rejects with `ENOENT`, the shape `isNotFoundError` recognises.
+ */
+declare const readBytesViaShell: (run: (argv: ReadonlyArray<string>) => Promise<ShellRun>) => (path: string, offset: number, length: number) => Promise<Uint8Array>;
+/**
+ * The backend-facing contract. Backends author plain promises and let them
+ * reject; {@link fromProvider} turns rejections into typed failures.
+ */
+interface Provider {
+  readonly readFile: (path: string) => Promise<string>;
+  readonly readFileBuffer: (path: string) => Promise<Uint8Array>;
+  /** Up to `length` bytes from `offset`; fewer at the end of the file. */
+  readonly readBytes: (path: string, offset: number, length: number) => Promise<Uint8Array>;
+  /**
+   * Write the file. Parents may be missing — do not create them here;
+   * {@link fromProvider} owns that guarantee for every backend.
+   */
+  readonly writeFile: (path: string, content: string | Uint8Array) => Promise<void>;
+  readonly stat: (path: string) => Promise<FileStat>;
+  readonly readdir: (path: string) => Promise<string[]>;
+  readonly exists: (path: string) => Promise<boolean>;
+  readonly mkdir: (path: string, options?: {
+    recursive?: boolean;
+  }) => Promise<void>;
+  readonly rm: (path: string, options?: RmOptions) => Promise<void>;
+  /** Canonical absolute path with symlinks resolved; rejects when the path does not exist. */
+  readonly realpath: (path: string) => Promise<string>;
+  /**
+   * A window of the file's lines, by the rules in `Scan`. Bounded: never
+   * returns, or holds, more than the window. A remote backend runs the scan
+   * inside the sandbox (`Scan.script`) so only the window crosses the network.
+   */
+  readonly scanLines: (path: string, options: LineScanOptions) => Promise<LineScan>;
+  /**
+   * Metadata for the directory entry itself rather than a symlink's target.
+   * Optional: a backend whose `stat` has mixed symlink semantics implements it
+   * so symlink identity is asked for explicitly, never inferred.
+   */
+  readonly lstat?: (path: string) => Promise<FileStat>;
+}
+/**
+ * The consumer-facing contract. `exists` distinguishes "absent" from "could not
+ * tell": a backend failure is a typed failure, not `false`, so a caller acting
+ * on absence never acts on a network blip. Use `SandboxFs.existsOrFalse` where
+ * a best-effort answer really is wanted.
+ */
+interface Interface {
+  readonly readFile: (path: string) => Effect.Effect<string, FileSystemError>;
+  readonly readFileBuffer: (path: string) => Effect.Effect<Uint8Array, FileSystemError>;
+  /** Up to `length` bytes from `offset`; fewer at the end of the file. */
+  readonly readBytes: (path: string, offset: number, length: number) => Effect.Effect<Uint8Array, FileSystemError>;
+  /** Creates missing parent directories, on every backend. */
+  readonly writeFile: (path: string, content: string | Uint8Array) => Effect.Effect<void, FileSystemError>;
+  readonly stat: (path: string) => Effect.Effect<FileStat, FileSystemError>;
+  readonly readdir: (path: string) => Effect.Effect<string[], FileSystemError>;
+  readonly exists: (path: string) => Effect.Effect<boolean, FileSystemError>;
+  readonly mkdir: (path: string, options?: {
+    recursive?: boolean;
+  }) => Effect.Effect<void, FileSystemError>;
+  readonly rm: (path: string, options?: RmOptions) => Effect.Effect<void, FileSystemError | OperationUnsupportedError>;
+  /** Canonical absolute path with symlinks resolved; fails when the path does not exist. */
+  readonly realpath: (path: string) => Effect.Effect<string, FileSystemError>;
+  /** A bounded window of the file's lines; see `Scan`. Invalid options are a defect. */
+  readonly scanLines: (path: string, options: LineScanOptions) => Effect.Effect<LineScan, FileSystemError>;
+  readonly lstat?: (path: string) => Effect.Effect<FileStat, FileSystemError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@codeworksh/plugin/sandbox/filesystem/Service", Interface>;
+/** The runtime filesystem service — the live {@link Interface} for the active sandbox. */
+declare class Service extends Service_base {}
+/**
+ * Reject `rm` options a provider does not implement, before any mutation. Only
+ * `recursive` and `force` are part of the contract; anything else is refused
+ * loudly rather than silently ignored.
+ */
+declare const validateRmOptions: (options: RmOptions | undefined, operation?: string) => Effect.Effect<void, OperationUnsupportedError>;
+/**
+ * Lift a {@link Provider} into the runtime {@link Interface}: one place that
+ * converts rejections into {@link FileSystemError}, validates `rm` options,
+ * creates missing parents on write, and names a tracing span per operation.
+ */
+declare const fromProvider: (provider: Provider) => Interface;
+/**
+ * Bind a cwd-neutral filesystem to one mount's working directory.
+ *
+ * The counterpart of `Shell.withCwd`, and the reason relative paths mean the
+ * same thing to both: a shared transport stays rooted at the namespace root, so
+ * resolution happens here, per mount, rather than inside a VFS whose `chdir` is
+ * global state two mounts would fight over.
+ */
+declare const withCwd: (fs: Interface, cwd: string) => Interface;
+//#endregion
+export { LineScanOptions as _, Provider as a, filesystem_d_exports as c, readBytesScript as d, readBytesViaShell as f, LineScan as g, withCwd as h, OperationUnsupportedError as i, fromProvider as l, validateRmOptions as m, FileSystemError as n, RmOptions as o, realpathScripts as p, Interface as r, Service as s, FileStat as t, isNotFoundError as u, scan_d_exports as v };
+//# sourceMappingURL=filesystem-CuGE9poU.d.mts.map