@shareai-lab/kode-sdk 2.7.1 → 2.7.2

package/dist/core/time-bridge.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeBridge = void 0;
+class TimeBridge {
+    constructor(opts) {
+        this.timers = new Map();
+        this.scheduler = opts.scheduler;
+        this.driftTolerance = opts.driftToleranceMs ?? 5000;
+        this.logger = opts.logger;
+    }
+    everyMinutes(minutes, callback) {
+        if (!Number.isFinite(minutes) || minutes <= 0) {
+            throw new Error('everyMinutes: interval must be positive');
+        }
+        const interval = minutes * 60 * 1000;
+        const id = this.generateId('minutes');
+        const scheduleNext = () => {
+            const due = Date.now() + interval;
+            const handle = setTimeout(() => tick(due), interval);
+            entry.cancel = () => clearTimeout(handle);
+        };
+        const spec = `every:${minutes}m`;
+        const tick = (due) => {
+            this.scheduler.enqueue(async () => {
+                const drift = Math.abs(Date.now() - due);
+                if (drift > this.driftTolerance) {
+                    this.logger?.('timebridge:drift', { id, drift, expectedInterval: interval });
+                }
+                await callback();
+                this.scheduler.notifyExternalTrigger({ taskId: id, spec, kind: 'time' });
+            });
+            scheduleNext();
+        };
+        const entry = {
+            id,
+            cancel: () => undefined,
+        };
+        this.timers.set(id, entry);
+        scheduleNext();
+        return id;
+    }
+    cron(expr, callback) {
+        const parts = expr.trim().split(/\s+/);
+        if (parts.length !== 5) {
+            throw new Error(`Unsupported cron expression: ${expr}`);
+        }
+        const minute = Number(parts[0]);
+        const hour = Number(parts[1]);
+        if (!Number.isInteger(minute) || !Number.isInteger(hour)) {
+            throw new Error(`Cron expression must be numeric minutes/hours: ${expr}`);
+        }
+        const id = this.generateId('cron');
+        const scheduleNext = () => {
+            const now = new Date();
+            const next = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, 0, 0);
+            if (next <= now) {
+                next.setDate(next.getDate() + 1);
+            }
+            const due = next.getTime();
+            const delay = Math.max(0, due - Date.now());
+            const handle = setTimeout(() => tick(due), delay);
+            entry.cancel = () => clearTimeout(handle);
+        };
+        const tick = (due) => {
+            this.scheduler.enqueue(async () => {
+                const drift = Math.abs(Date.now() - due);
+                if (drift > this.driftTolerance) {
+                    this.logger?.('timebridge:drift', { id, drift, spec: expr });
+                }
+                await callback();
+                this.scheduler.notifyExternalTrigger({ taskId: id, spec: expr, kind: 'cron' });
+            });
+            scheduleNext();
+        };
+        const entry = {
+            id,
+            cancel: () => undefined,
+        };
+        this.timers.set(id, entry);
+        scheduleNext();
+        return id;
+    }
+    stop(timerId) {
+        const entry = this.timers.get(timerId);
+        if (!entry)
+            return;
+        entry.cancel();
+        this.timers.delete(timerId);
+    }
+    dispose() {
+        for (const entry of this.timers.values()) {
+            entry.cancel();
+        }
+        this.timers.clear();
+    }
+    generateId(prefix) {
+        return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    }
+}
+exports.TimeBridge = TimeBridge;

package/dist/core/todo.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TodoService = void 0;
+const MAX_IN_PROGRESS = 1;
+class TodoService {
+    constructor(store, agentId) {
+        this.store = store;
+        this.agentId = agentId;
+        this.snapshot = { todos: [], version: 1, updatedAt: Date.now() };
+    }
+    async load() {
+        const existing = await this.store.loadTodos?.(this.agentId);
+        if (existing) {
+            this.snapshot = existing;
+        }
+    }
+    list() {
+        return [...this.snapshot.todos];
+    }
+    async setTodos(todos) {
+        const normalized = todos.map((todo) => this.normalize(todo));
+        this.validateTodos(normalized);
+        this.snapshot = {
+            todos: normalized.map((todo) => ({ ...todo, updatedAt: Date.now() })),
+            version: this.snapshot.version + 1,
+            updatedAt: Date.now(),
+        };
+        await this.persist();
+    }
+    async update(todo) {
+        const existing = this.snapshot.todos.find((t) => t.id === todo.id);
+        if (!existing) {
+            throw new Error(`Todo not found: ${todo.id}`);
+        }
+        const normalized = this.normalize({ ...existing, ...todo });
+        const updated = { ...existing, ...normalized, updatedAt: Date.now() };
+        const next = this.snapshot.todos.map((t) => (t.id === todo.id ? updated : t));
+        this.validateTodos(next);
+        this.snapshot.todos = next;
+        this.snapshot.version += 1;
+        this.snapshot.updatedAt = Date.now();
+        await this.persist();
+    }
+    async delete(id) {
+        const next = this.snapshot.todos.filter((t) => t.id !== id);
+        this.snapshot.todos = next;
+        this.snapshot.version += 1;
+        this.snapshot.updatedAt = Date.now();
+        await this.persist();
+    }
+    validateTodos(todos) {
+        const ids = new Set();
+        let inProgress = 0;
+        for (const todo of todos) {
+            if (!todo.id)
+                throw new Error('Todo id is required');
+            if (ids.has(todo.id)) {
+                throw new Error(`Duplicate todo id: ${todo.id}`);
+            }
+            ids.add(todo.id);
+            if (todo.status === 'in_progress')
+                inProgress += 1;
+            if (!todo.title?.trim()) {
+                throw new Error(`Todo ${todo.id} must have a title`);
+            }
+        }
+        if (inProgress > MAX_IN_PROGRESS) {
+            throw new Error('Only one todo can be in progress');
+        }
+    }
+    async persist() {
+        if (!this.store.saveTodos)
+            return;
+        await this.store.saveTodos(this.agentId, this.snapshot);
+    }
+    normalize(todo) {
+        const now = Date.now();
+        return {
+            id: todo.id,
+            title: todo.title,
+            status: todo.status,
+            assignee: todo.assignee,
+            notes: todo.notes,
+            createdAt: todo.createdAt ?? now,
+            updatedAt: todo.updatedAt ?? now,
+        };
+    }
+}
+exports.TodoService = TodoService;

package/dist/core/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Core type definitions for KODE SDK v2.7
+Object.defineProperty(exports, "__esModule", { value: true });