kernl 0.1.1

package/dist/sched/task.js

@@ -0,0 +1,102 @@
+/**
+ * A Task represents a unit of work scheduled by the kernl.
+ * Analogous to task_struct in the Linux kernel.
+ */
+export class Task {
+    pid;
+    // tgid: string | null; /* task groupid */
+    // prio: TaskPriority;
+    instructions;
+    // sched: TaskSched; /* scheduling (timers, timeouts, deadlines) */
+    state;
+    owner;
+    context;
+    // cred: Credentials; /* Effective (overridable) subjective task credentials (COW): */
+    // realcred: Credentials; /* Objective and real subjective task credentials (COW): */
+    /**
+     * Might want the ability to pick up a new thread of execution from a compressed task checkpoint instead of including
+     * all of the events from the old threads (which may no longer be useful if they completed with good artifacts + reasoning / action summaries).
+     * At that point its really more about tracing.
+     */
+    threads;
+    current;
+    result;
+    // checkpoints: TaskCheckpoint<TContext>[]; /* checkpoints for resuming execution */
+    // TODO: Deferred fields for later implementation
+    // tgid: string;              // Thread group ID
+    // limits: TaskLimits;        // Resource limits (max ticks, tokens, timeout)
+    // nsproxy: NamespaceProxy;   // Namespace isolation
+    constructor(init) {
+        this.pid = init.pid;
+        this.instructions = init.instructions;
+        this.state = init.state;
+        this.owner = init.owner;
+        this.context = init.context;
+        this.threads = [];
+        this.current = null;
+        this.result = null;
+    }
+}
+/**
+ * The various states that a task may be in.
+ */
+export var TaskState;
+(function (TaskState) {
+    /**
+     * Task is either:
+     * - Currently executing
+     * - In run queue waiting to be scheduled (might want to differentiate between running + queued here)
+     */
+    TaskState["RUNNING"] = "running";
+    /**
+     * Task is sleeping/blocked, waiting for a condition.
+     * Can be woken up by:
+     * - The condition being met (e.g., approval granted)
+     * - A signal (e.g., user cancellation)
+     *
+     * Examples:
+     * - Waiting for tool approval
+     * - Waiting for user input
+     * - Sleeping on a timer
+     */
+    TaskState["INTERRUPTIBLE"] = "interruptible";
+    /**
+     * Task is sleeping/blocked and CANNOT be interrupted by signals.
+     * Only wakes when the condition is met.
+     *
+     * Examples:
+     * - Waiting for critical I/O (model API call)
+     * - Waiting for resource that MUST complete
+     *
+     * Use sparingly - these tasks can't be cancelled!
+     */
+    TaskState["UNINTERRUPTIBLE"] = "uninterruptible";
+    /**
+     * Task has been stopped by a signal (SIGSTOP).
+     * Will remain stopped until explicitly continued (SIGCONT).
+     *
+     * Examples:
+     * - User explicitly paused the agent
+     * - Debugger attached
+     */
+    TaskState["STOPPED"] = "stopped";
+    /**
+     * Task is being traced by a debugger.
+     * Similar to STOPPED but for debugging.
+     */
+    TaskState["TRACED"] = "traced";
+    /**
+     * Task has finished execution but hasn't been cleaned up yet.
+     * Waiting for parent to read exit status (wait/waitpid).
+     *
+     * Examples:
+     * - Agent completed but result not yet retrieved
+     * - Child agent finished, parent needs to collect result
+     */
+    TaskState["ZOMBIE"] = "zombie";
+    /**
+     * Task is being removed from the system.
+     * Final cleanup in progress, about to be fully deleted.
+     */
+    TaskState["DEAD"] = "dead";
+})(TaskState || (TaskState = {}));

package/dist/serde/__tests__/codec.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=codec.test.d.ts.map

package/dist/serde/__tests__/codec.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.test.d.ts","sourceRoot":"","sources":["../../../src/serde/__tests__/codec.test.ts"],"names":[],"mappings":""}

package/dist/serde/__tests__/codec.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect } from "vitest";
+import { z } from "zod";
+import { json } from "../codec";
+describe("json codec", () => {
+    it("should parse valid JSON and validate against schema", () => {
+        const schema = z.object({
+            name: z.string(),
+            age: z.number(),
+        });
+        const codec = json(schema);
+        const result = codec.decode('{"name": "Alice", "age": 30}');
+        expect(result).toEqual({ name: "Alice", age: 30 });
+    });
+    it("should reject invalid JSON syntax", () => {
+        const schema = z.object({
+            name: z.string(),
+        });
+        const codec = json(schema);
+        expect(() => {
+            codec.decode('{"name": "Alice"');
+        }).toThrow();
+    });
+    it("should reject valid JSON that doesn't match schema", () => {
+        const schema = z.object({
+            name: z.string(),
+            age: z.number(),
+        });
+        const codec = json(schema);
+        // Valid JSON but age is a string, not a number
+        expect(() => {
+            codec.decode('{"name": "Alice", "age": "30"}');
+        }).toThrow();
+    });
+    it("should reject JSON missing required fields", () => {
+        const schema = z.object({
+            name: z.string(),
+            age: z.number(),
+        });
+        const codec = json(schema);
+        // Valid JSON but missing age field
+        expect(() => {
+            codec.decode('{"name": "Alice"}');
+        }).toThrow();
+    });
+    it("should handle nested objects", () => {
+        const schema = z.object({
+            user: z.object({
+                name: z.string(),
+                email: z.string().email(),
+            }),
+            metadata: z.object({
+                createdAt: z.string(),
+            }),
+        });
+        const codec = json(schema);
+        const result = codec.decode('{"user": {"name": "Bob", "email": "bob@example.com"}, "metadata": {"createdAt": "2024-01-01"}}');
+        expect(result).toEqual({
+            user: { name: "Bob", email: "bob@example.com" },
+            metadata: { createdAt: "2024-01-01" },
+        });
+    });
+    it("should reject nested objects that don't match schema", () => {
+        const schema = z.object({
+            user: z.object({
+                name: z.string(),
+                email: z.string().email(),
+            }),
+        });
+        const codec = json(schema);
+        // Invalid email format
+        expect(() => {
+            codec.decode('{"user": {"name": "Bob", "email": "not-an-email"}}');
+        }).toThrow();
+    });
+});

package/dist/serde/codec.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const stringToNumber: z.ZodCodec<z.ZodString, z.ZodNumber>;
+export declare const stringToInt: z.ZodCodec<z.ZodString, z.ZodInt>;
+export declare const isotime: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+export declare const epochsec: z.ZodCodec<z.ZodInt, z.ZodDate>;
+export declare const epochms: z.ZodCodec<z.ZodInt, z.ZodDate>;
+export declare const json: <T extends z.core.$ZodType>(schema: T) => z.ZodCodec<z.ZodString, T>;
+export declare const stringToURL: z.ZodCodec<z.ZodURL, z.ZodCustom<import("url").URL, import("url").URL>>;
+export declare const stringToHttpURL: z.ZodCodec<z.ZodURL, z.ZodCustom<import("url").URL, import("url").URL>>;
+export declare const base64ToBytes: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+export declare const base64urlToBytes: z.ZodCodec<z.ZodBase64URL, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+//# sourceMappingURL=codec.d.ts.map

package/dist/serde/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/serde/codec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc,sCAO1B,CAAC;AAEF,eAAO,MAAM,WAAW,mCAOvB,CAAC;AAEF,eAAO,MAAM,OAAO,yCAGlB,CAAC;AAEH,eAAO,MAAM,QAAQ,iCAGnB,CAAC;AAEH,eAAO,MAAM,OAAO,iCAGlB,CAAC;AAEH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,+BAgBrD,CAAC;AAEL,eAAO,MAAM,WAAW,yEAGtB,CAAC;AAEH,eAAO,MAAM,eAAe,yEAG1B,CAAC;AAEH,eAAO,MAAM,aAAa,wFAGxB,CAAC;AAEH,eAAO,MAAM,gBAAgB,2FAO5B,CAAC"}

package/dist/serde/codec.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export const stringToNumber = z.codec(z.string().regex(z.regexes.number), z.number(), {
+    decode: (str) => Number.parseFloat(str),
+    encode: (num) => num.toString(),
+});
+export const stringToInt = z.codec(z.string().regex(z.regexes.integer), z.int(), {
+    decode: (str) => Number.parseInt(str, 10),
+    encode: (num) => num.toString(),
+});
+export const isotime = z.codec(z.iso.datetime(), z.date(), {
+    decode: (isoString) => new Date(isoString),
+    encode: (date) => date.toISOString(),
+});
+export const epochsec = z.codec(z.int().min(0), z.date(), {
+    decode: (seconds) => new Date(seconds * 1000),
+    encode: (date) => Math.floor(date.getTime() / 1000),
+});
+export const epochms = z.codec(z.int().min(0), z.date(), {
+    decode: (millis) => new Date(millis),
+    encode: (date) => date.getTime(),
+});
+export const json = (schema) => z.codec(z.string(), schema, {
+    decode: (jsonString, ctx) => {
+        try {
+            return JSON.parse(jsonString);
+        }
+        catch (err) {
+            ctx.issues.push({
+                code: "invalid_format",
+                format: "json",
+                input: jsonString,
+                message: err.message,
+            });
+            return z.NEVER;
+        }
+    },
+    encode: (value) => JSON.stringify(value),
+});
+export const stringToURL = z.codec(z.url(), z.instanceof(URL), {
+    decode: (urlString) => new URL(urlString),
+    encode: (url) => url.href,
+});
+export const stringToHttpURL = z.codec(z.httpUrl(), z.instanceof(URL), {
+    decode: (urlString) => new URL(urlString),
+    encode: (url) => url.href,
+});
+export const base64ToBytes = z.codec(z.base64(), z.instanceof(Uint8Array), {
+    decode: (base64String) => z.util.base64ToUint8Array(base64String),
+    encode: (bytes) => z.util.uint8ArrayToBase64(bytes),
+});
+export const base64urlToBytes = z.codec(z.base64url(), z.instanceof(Uint8Array), {
+    decode: (base64urlString) => z.util.base64urlToUint8Array(base64urlString),
+    encode: (bytes) => z.util.uint8ArrayToBase64url(bytes),
+});

package/dist/serde/json.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/**
+ * Represents a JSON-serializable value that can be safely stringified and sent to the model.
+ * Recursive type that allows nested structures.
+ */
+export declare const JSONValue: z.ZodType<unknown>;
+export type JSONValue = z.infer<typeof JSONValue>;
+//# sourceMappingURL=json.d.ts.map

package/dist/serde/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/serde/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CASxC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/serde/json.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+/**
+ * Represents a JSON-serializable value that can be safely stringified and sent to the model.
+ * Recursive type that allows nested structures.
+ */
+export const JSONValue = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JSONValue),
+    z.record(z.string(), JSONValue),
+]));