@hivemagnus/ardent 0.0.0-stage → 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { ArdentRuntime, type RunResult } from './runtime.js';
+export { ConfigSchema, loadConfig, initProfile, saveConfig, profilePath, parseConfig, runtimeProblems, type ArdentConfig, type LoadedConfig } from './config.js';
+export { ResearchBriefSchema } from './research.js';
+export { TaskStore, type Task } from './store.js';
+export { defineTool, ToolRegistry, ProvenNoEffectError, type Tool, type ToolContext, type ToolEffect, type ToolResult } from './tools.js';
+export { createArdentApi, ardentOpenApi } from './api.js';
+export { JobEngine, validateJobDefinitions, type JobContext, type JobDefinition, type JobHandler, type JobRegistry, type JobResult, type OwnershipCheck } from './job-engine.js';
+export { definePlugin, registerPlugin, registeredPlugins, clearRegisteredPlugins, loadPlugins, type ArdentPlugin, type ArdentPluginContext, type ArdentCliCommand, type ArdentCliInvocation } from './plugins.js';
+export type { TeamEnvelope, TeamMission, TeamResult } from './team-contract.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { ArdentRuntime } from './runtime.js';
+export { ConfigSchema, loadConfig, initProfile, saveConfig, profilePath, parseConfig, runtimeProblems } from './config.js';
+export { ResearchBriefSchema } from './research.js';
+export { TaskStore } from './store.js';
+export { defineTool, ToolRegistry, ProvenNoEffectError } from './tools.js';
+export { createArdentApi, ardentOpenApi } from './api.js';
+export { JobEngine, validateJobDefinitions } from './job-engine.js';
+export { definePlugin, registerPlugin, registeredPlugins, clearRegisteredPlugins, loadPlugins } from './plugins.js';

package/dist/job-engine.d.ts

@@ -0,0 +1,222 @@
+import type Database from 'better-sqlite3';
+import { z } from 'zod';
+declare const definition: z.ZodObject<{
+    id: z.ZodString;
+    owner: z.ZodEnum<{
+        external: "external";
+        ardent: "ardent";
+    }>;
+    enabled: z.ZodBoolean;
+    handler: z.ZodString;
+    schedule: z.ZodUnion<readonly [z.ZodObject<{
+        cron: z.ZodString;
+        timezone: z.ZodString;
+        missed_window: z.ZodEnum<{
+            skip: "skip";
+            catch_up: "catch_up";
+        }>;
+        catch_up_minutes: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"interval">;
+        every_minutes: z.ZodNumber;
+        anchor_at: z.ZodString;
+    }, z.core.$strict>]>;
+    input: z.ZodOptional<z.ZodUnknown>;
+    delivery: z.ZodObject<{
+        kind: z.ZodEnum<{
+            none: "none";
+            telegram: "telegram";
+            mattermost: "mattermost";
+        }>;
+        target_ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        retry_backoff_seconds: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const JobDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    owner: z.ZodEnum<{
+        external: "external";
+        ardent: "ardent";
+    }>;
+    enabled: z.ZodBoolean;
+    handler: z.ZodString;
+    schedule: z.ZodUnion<readonly [z.ZodObject<{
+        cron: z.ZodString;
+        timezone: z.ZodString;
+        missed_window: z.ZodEnum<{
+            skip: "skip";
+            catch_up: "catch_up";
+        }>;
+        catch_up_minutes: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"interval">;
+        every_minutes: z.ZodNumber;
+        anchor_at: z.ZodString;
+    }, z.core.$strict>]>;
+    input: z.ZodOptional<z.ZodUnknown>;
+    delivery: z.ZodObject<{
+        kind: z.ZodEnum<{
+            none: "none";
+            telegram: "telegram";
+            mattermost: "mattermost";
+        }>;
+        target_ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        retry_backoff_seconds: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type JobDefinition = z.infer<typeof definition>;
+export declare const JobDefinitionsSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    profile: z.ZodString;
+    revision: z.ZodNumber;
+    jobs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        owner: z.ZodEnum<{
+            external: "external";
+            ardent: "ardent";
+        }>;
+        enabled: z.ZodBoolean;
+        handler: z.ZodString;
+        schedule: z.ZodUnion<readonly [z.ZodObject<{
+            cron: z.ZodString;
+            timezone: z.ZodString;
+            missed_window: z.ZodEnum<{
+                skip: "skip";
+                catch_up: "catch_up";
+            }>;
+            catch_up_minutes: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"interval">;
+            every_minutes: z.ZodNumber;
+            anchor_at: z.ZodString;
+        }, z.core.$strict>]>;
+        input: z.ZodOptional<z.ZodUnknown>;
+        delivery: z.ZodObject<{
+            kind: z.ZodEnum<{
+                none: "none";
+                telegram: "telegram";
+                mattermost: "mattermost";
+            }>;
+            target_ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        policy: z.ZodObject<{
+            max_attempts: z.ZodNumber;
+            retry_backoff_seconds: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type JobDefinitions = z.infer<typeof JobDefinitionsSchema>;
+export type JobReceipt = {
+    effect_status: 'none' | 'confirmed' | 'unknown';
+    evidence?: unknown;
+};
+export type JobResult = {
+    state: 'completed' | 'retry' | 'failed' | 'unknown';
+    receipt: JobReceipt;
+};
+export type JobContext = {
+    job: JobDefinition;
+    input: unknown;
+    window_key: string;
+    scheduled_at: Date;
+    now: Date;
+    attempt: number;
+    signal: AbortSignal;
+    /** Aborts when the scheduler stops admitting work; a handler must not claim new delivery rows after it fires. */
+    stopping?: AbortSignal;
+};
+export type JobHandler = {
+    input: z.ZodType<unknown>;
+    delivery?: z.ZodType<unknown>;
+    effect: 'none' | 'external';
+    run(ctx: JobContext): Promise<JobResult>;
+};
+export type JobRegistry = Record<string, JobHandler>;
+export type OwnershipCheck = (job: JobDefinition, now: Date) => Promise<void>;
+declare const rowSchema: z.ZodObject<{
+    window_key: z.ZodString;
+    job_id: z.ZodString;
+    local_key: z.ZodString;
+    scheduled_ms: z.ZodNumber;
+    definition_revision: z.ZodNumber;
+    definition_sha256: z.ZodString;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        queued: "queued";
+        failed: "failed";
+        completed: "completed";
+        running: "running";
+        retry: "retry";
+        superseded: "superseded";
+    }>;
+    attempts: z.ZodNumber;
+    next_attempt_ms: z.ZodNumber;
+    receipt_json: z.ZodNullable<z.ZodString>;
+    receipt_sha256: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    updated_ms: z.ZodNumber;
+}, z.core.$strip>;
+export type JobWindow = z.infer<typeof rowSchema>;
+export type JobWindowStatus = Omit<JobWindow, 'receipt_json' | 'error'> & {
+    error: string | null;
+};
+/** Validates all data before it can be selected. Definitions are data, never executable code. */
+export declare function validateJobDefinitions(raw: unknown, registry: JobRegistry, expectedProfile?: string): {
+    definitions: JobDefinitions;
+    sha256: string;
+    job_count: number;
+};
+/** A profile-local SQLite scheduler. No work is admitted without a fresh ownership check. */
+export declare class JobEngine {
+    #private;
+    readonly db: Database.Database;
+    readonly profileDir: string;
+    readonly profile: string;
+    readonly registry: JobRegistry;
+    readonly ownershipCheck: OwnershipCheck;
+    readonly clock: () => number;
+    /** `clock` measures elapsed time within a tick; the injected tick time stays the timeline origin. */
+    constructor(db: Database.Database, profileDir: string, profile: string, registry: JobRegistry, ownershipCheck: OwnershipCheck, clock?: () => number);
+    load(): Promise<{
+        definitions: JobDefinitions;
+        sha256: string;
+        job_count: number;
+    }>;
+    recover(now?: Date): number;
+    /** Startup reconciliation requires the gateway's exclusive profile lock. */
+    recoverAfterRestart(now?: Date): Promise<number>;
+    status(limit?: number, now?: Date): Promise<{
+        active_revision: number | null;
+        active_sha256: string | null;
+        last_validation_error: string | null;
+        active_jobs: number;
+        unknown_jobs: number;
+        counts: Record<string, number>;
+        jobs: Array<{
+            job_id: string;
+            next_window: string | null;
+            last_window: string | null;
+            counts: Record<string, number>;
+        }>;
+        windows: JobWindowStatus[];
+    }>;
+    /**
+     * `now` selects which windows are due. Ownership checks, claims, receipts and
+     * retry backoff use a fresh instant on the same timeline. `signal` aborts
+     * running handlers; `stopping` only prevents new claims.
+     */
+    tick(now?: Date, signal?: AbortSignal, stopping?: AbortSignal): Promise<{
+        scanned: number;
+        claimed: number;
+        completed: number;
+        retry: number;
+        unknown: number;
+    }>;
+}
+export {};