codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/cron/store/cron-schema.ts

@@ -0,0 +1,127 @@
+import type { SqliteDb } from "@cline/shared/db";
+
+/**
+ * Bootstrap the dedicated cron.db schema. Unlike @cline/shared's
+ * `ensureSessionSchema`, this schema is fully owned by @cline/core
+ * because cron lifecycle (specs, runs, reports) is a core concern and
+ * should not be coupled to session storage.
+ */
+
+const CRON_SCHEMA_STATEMENTS: readonly string[] = [
+	`CREATE TABLE IF NOT EXISTS cron_specs (
+		spec_id TEXT PRIMARY KEY,
+		external_id TEXT NOT NULL,
+		source_path TEXT NOT NULL UNIQUE,
+		trigger_kind TEXT NOT NULL CHECK (trigger_kind IN ('one_off', 'schedule', 'event')),
+		source_mtime_ms INTEGER,
+		source_hash TEXT,
+		parse_status TEXT NOT NULL CHECK (parse_status IN ('valid', 'invalid')),
+		parse_error TEXT,
+		enabled INTEGER NOT NULL DEFAULT 1,
+		removed INTEGER NOT NULL DEFAULT 0,
+		title TEXT NOT NULL,
+		prompt TEXT,
+		workspace_root TEXT,
+		schedule_expr TEXT,
+		timezone TEXT,
+		event_type TEXT,
+		filters_json TEXT,
+		debounce_seconds INTEGER,
+		dedupe_window_seconds INTEGER,
+		cooldown_seconds INTEGER,
+		mode TEXT,
+		system_prompt TEXT,
+		provider_id TEXT,
+		model_id TEXT,
+		max_iterations INTEGER,
+		timeout_seconds INTEGER,
+		max_parallel INTEGER,
+		tools_json TEXT,
+		notes_directory TEXT,
+		extensions_json TEXT,
+		source TEXT,
+		tags_json TEXT,
+		metadata_json TEXT,
+		revision INTEGER NOT NULL DEFAULT 1,
+		last_materialized_run_id TEXT,
+		last_run_at TEXT,
+		next_run_at TEXT,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	);`,
+	`CREATE TABLE IF NOT EXISTS cron_runs (
+		run_id TEXT PRIMARY KEY,
+		spec_id TEXT NOT NULL REFERENCES cron_specs(spec_id) ON DELETE CASCADE,
+		spec_revision INTEGER NOT NULL,
+		trigger_kind TEXT NOT NULL CHECK (trigger_kind IN ('one_off', 'schedule', 'event', 'manual', 'retry')),
+		status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'done', 'failed', 'cancelled')),
+		claim_token TEXT,
+		claim_started_at TEXT,
+		claim_until_at TEXT,
+		scheduled_for TEXT,
+		trigger_event_id TEXT,
+		started_at TEXT,
+		completed_at TEXT,
+		session_id TEXT,
+		report_path TEXT,
+		error TEXT,
+		attempt_count INTEGER NOT NULL DEFAULT 0,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	);`,
+	`CREATE TABLE IF NOT EXISTS cron_event_log (
+		event_id TEXT PRIMARY KEY,
+		event_type TEXT NOT NULL,
+		source TEXT NOT NULL,
+		subject TEXT,
+		occurred_at TEXT NOT NULL,
+		received_at TEXT NOT NULL,
+		workspace_root TEXT,
+		dedupe_key TEXT,
+		payload_json TEXT,
+		attributes_json TEXT,
+		processing_status TEXT NOT NULL DEFAULT 'received'
+			CHECK (processing_status IN ('received', 'unmatched', 'queued', 'suppressed', 'failed')),
+		matched_spec_count INTEGER NOT NULL DEFAULT 0,
+		queued_run_count INTEGER NOT NULL DEFAULT 0,
+		suppressed_count INTEGER NOT NULL DEFAULT 0,
+		error TEXT,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	);`,
+	`DROP INDEX IF EXISTS cron_runs_one_off_active_idx;`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS cron_runs_one_off_active_idx
+		ON cron_runs(spec_id, spec_revision)
+		WHERE trigger_kind = 'one_off';`,
+	`CREATE INDEX IF NOT EXISTS cron_runs_claimable_idx
+		ON cron_runs(status, scheduled_for, claim_until_at);`,
+	`CREATE INDEX IF NOT EXISTS cron_runs_spec_idx
+		ON cron_runs(spec_id, created_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_runs_trigger_event_idx
+		ON cron_runs(trigger_event_id);`,
+	`CREATE INDEX IF NOT EXISTS cron_runs_event_spec_status_idx
+		ON cron_runs(spec_id, trigger_kind, status, scheduled_for);`,
+	`CREATE INDEX IF NOT EXISTS cron_event_log_type_idx
+		ON cron_event_log(event_type, received_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_event_log_received_idx
+		ON cron_event_log(received_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_event_log_dedupe_idx
+		ON cron_event_log(event_type, source, dedupe_key, received_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_specs_next_run_idx
+		ON cron_specs(trigger_kind, enabled, next_run_at);`,
+	`CREATE INDEX IF NOT EXISTS cron_specs_event_match_idx
+		ON cron_specs(trigger_kind, event_type, enabled);`,
+	`CREATE INDEX IF NOT EXISTS cron_specs_parse_status_idx
+		ON cron_specs(parse_status, updated_at DESC);`,
+	`CREATE INDEX IF NOT EXISTS cron_specs_source_path_idx
+		ON cron_specs(source_path);`,
+];
+
+export function ensureCronSchema(db: SqliteDb): void {
+	db.exec("PRAGMA journal_mode = WAL;");
+	db.exec("PRAGMA busy_timeout = 5000;");
+	db.exec("PRAGMA foreign_keys = ON;");
+	for (const stmt of CRON_SCHEMA_STATEMENTS) {
+		db.exec(stmt);
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/cron/store/index.ts

@@ -0,0 +1,2 @@
+export * from "./cron-schema";
+export * from "./sqlite-cron-store";

codna/agent-core/vendor/cline/sdk/packages/core/src/cron/store/sqlite-cron-store.test.ts

@@ -0,0 +1,354 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CronOneOffSpec, CronScheduleSpec } from "@cline/shared";
+import { loadSqliteDb } from "@cline/shared/db";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SqliteCronStore } from "./sqlite-cron-store";
+
+function tempDbPath(): { dir: string; path: string } {
+	const dir = mkdtempSync(join(tmpdir(), "cline-cron-store-"));
+	return { dir, path: join(dir, "cron.db") };
+}
+
+describe("SqliteCronStore", () => {
+	let dir: string;
+	let store: SqliteCronStore;
+
+	beforeEach(() => {
+		const tmp = tempDbPath();
+		dir = tmp.dir;
+		store = new SqliteCronStore({ dbPath: tmp.path });
+	});
+
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	const baseOneOff = (): CronOneOffSpec => ({
+		triggerKind: "one_off",
+		id: "cleanup",
+		title: "Clean",
+		prompt: "Remove stale files",
+		workspaceRoot: "/ws",
+		enabled: true,
+	});
+
+	it("creates a new spec row for a new source path", () => {
+		const result = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: baseOneOff(),
+		});
+		expect(result.created).toBe(true);
+		expect(result.revisionChanged).toBe(true);
+		expect(result.record.revision).toBe(1);
+		expect(result.record.enabled).toBe(true);
+		expect(result.record.parseStatus).toBe("valid");
+		expect(result.record.prompt).toBe("Remove stale files");
+	});
+
+	it("persists cron runtime controls", () => {
+		const result = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: {
+				...baseOneOff(),
+				tools: ["run_commands", "read_files"],
+				notesDirectory: "/notes",
+				extensions: ["rules", "skills"],
+				source: "automation",
+			},
+		});
+		expect(result.record.tools).toEqual(["run_commands", "read_files"]);
+		expect(result.record.notesDirectory).toBe("/notes");
+		expect(result.record.extensions).toEqual(["rules", "skills"]);
+		expect(result.record.source).toBe("automation");
+	});
+
+	it("does not bump revision on cosmetic-only re-upsert with same hash", () => {
+		store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: baseOneOff(),
+		});
+		const result = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: baseOneOff(),
+		});
+		expect(result.created).toBe(false);
+		expect(result.revisionChanged).toBe(false);
+		expect(result.record.revision).toBe(1);
+	});
+
+	it("bumps revision when the prompt changes", () => {
+		store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash1",
+			parseStatus: "valid",
+			spec: baseOneOff(),
+		});
+		const result = store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "hash2",
+			parseStatus: "valid",
+			spec: { ...baseOneOff(), prompt: "New prompt" },
+		});
+		expect(result.revisionChanged).toBe(true);
+		expect(result.record.revision).toBe(2);
+	});
+
+	it("records invalid parse status without a spec", () => {
+		const result = store.upsertSpec({
+			externalId: "bad.md",
+			sourcePath: "bad.md",
+			triggerKind: "one_off",
+			sourceHash: "bad",
+			parseStatus: "invalid",
+			parseError: "boom",
+		});
+		expect(result.record.parseStatus).toBe("invalid");
+		expect(result.record.enabled).toBe(false);
+		expect(result.record.parseError).toBe("boom");
+	});
+});
+
+describe("SqliteCronStore: schema migrations", () => {
+	it("recreates the one-off run uniqueness index when its predicate changes", () => {
+		const tmp = tempDbPath();
+		const initialStore = new SqliteCronStore({ dbPath: tmp.path });
+		initialStore.close();
+
+		const db = loadSqliteDb(tmp.path);
+		try {
+			db.exec("DROP INDEX IF EXISTS cron_runs_one_off_active_idx;");
+			db.exec(`CREATE UNIQUE INDEX cron_runs_one_off_active_idx
+				ON cron_runs(spec_id, spec_revision)
+				WHERE trigger_kind = 'one_off' AND status IN ('queued', 'running');`);
+			const before = db
+				.prepare(
+					"SELECT sql FROM sqlite_master WHERE type = 'index' AND name = 'cron_runs_one_off_active_idx'",
+				)
+				.get();
+			expect(String(before?.sql)).toContain("status IN");
+		} finally {
+			db.close?.();
+		}
+
+		const migratedStore = new SqliteCronStore({ dbPath: tmp.path });
+		migratedStore.close();
+
+		const migratedDb = loadSqliteDb(tmp.path);
+		try {
+			const after = migratedDb
+				.prepare(
+					"SELECT sql FROM sqlite_master WHERE type = 'index' AND name = 'cron_runs_one_off_active_idx'",
+				)
+				.get();
+			const indexSql = String(after?.sql);
+			expect(indexSql).toContain("WHERE trigger_kind = 'one_off'");
+			expect(indexSql).not.toContain("status IN");
+		} finally {
+			migratedDb.close?.();
+			rmSync(tmp.dir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("SqliteCronStore: runs", () => {
+	let dir: string;
+	let store: SqliteCronStore;
+
+	beforeEach(() => {
+		const tmp = tempDbPath();
+		dir = tmp.dir;
+		store = new SqliteCronStore({ dbPath: tmp.path });
+	});
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	function seedOneOff() {
+		return store.upsertSpec({
+			externalId: "cleanup",
+			sourcePath: "cleanup.md",
+			triggerKind: "one_off",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec: {
+				triggerKind: "one_off",
+				id: "cleanup",
+				title: "Clean",
+				prompt: "p",
+				workspaceRoot: "/ws",
+				enabled: true,
+			},
+		}).record;
+	}
+
+	it("enqueues a queued one-off run and detects duplicates", () => {
+		const spec = seedOneOff();
+		expect(store.hasOneOffRunForRevision(spec.specId, 1)).toBe(false);
+		const run = store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+			scheduledFor: new Date().toISOString(),
+		});
+		expect(run.status).toBe("queued");
+		expect(run.triggerKind).toBe("one_off");
+		expect(store.hasOneOffRunForRevision(spec.specId, 1)).toBe(true);
+	});
+
+	it("treats failed one-off runs as satisfying the revision", () => {
+		const spec = seedOneOff();
+		const run = store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+		});
+		store.completeRun(run.runId, { status: "failed", error: "boom" });
+		expect(store.hasOneOffRunForRevision(spec.specId, 1)).toBe(true);
+	});
+
+	it("claims due queued runs and completes them", () => {
+		const spec = seedOneOff();
+		store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+			scheduledFor: new Date().toISOString(),
+		});
+		const claims = store.claimDueRuns({
+			nowIso: new Date().toISOString(),
+			leaseMs: 30_000,
+		});
+		expect(claims.length).toBe(1);
+		expect(claims[0]?.run.status).toBe("running");
+		const ok = store.completeRun(claims[0]?.run.runId, {
+			status: "done",
+			reportPath: "/tmp/report.md",
+		});
+		expect(ok).toBe(true);
+		const run = store.getRun(claims[0]?.run.runId);
+		expect(run?.status).toBe("done");
+		expect(run?.reportPath).toBe("/tmp/report.md");
+	});
+
+	it("reclaims expired running leases", () => {
+		const spec = seedOneOff();
+		store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+		});
+		const firstClaims = store.claimDueRuns({
+			nowIso: "2026-04-23T10:00:00.000Z",
+			leaseMs: 1_000,
+		});
+		expect(firstClaims).toHaveLength(1);
+		const reclaimed = store.claimDueRuns({
+			nowIso: "2026-04-23T10:00:02.000Z",
+			leaseMs: 1_000,
+		});
+		expect(reclaimed).toHaveLength(1);
+		expect(reclaimed[0]?.run.runId).toBe(firstClaims[0]?.run.runId);
+		expect(reclaimed[0]?.claimToken).not.toBe(firstClaims[0]?.claimToken);
+		expect(reclaimed[0]?.run.attemptCount).toBe(2);
+	});
+
+	it("cancels queued runs when the spec is removed", () => {
+		const spec = seedOneOff();
+		store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+		});
+		expect(store.cancelQueuedRunsForSpec(spec.specId)).toBe(1);
+		const runs = store.listRuns({ specId: spec.specId });
+		expect(runs[0]?.status).toBe("cancelled");
+	});
+
+	it("requeues a claimed run when ownership matches", () => {
+		const spec = seedOneOff();
+		const queued = store.enqueueRun({
+			specId: spec.specId,
+			specRevision: 1,
+			triggerKind: "one_off",
+		});
+		const [claim] = store.claimDueRuns({
+			nowIso: "2026-04-23T10:00:00.000Z",
+			leaseMs: 10_000,
+		});
+		expect(claim?.run.runId).toBe(queued.runId);
+		expect(
+			store.requeueRun({
+				runId: claim?.run.runId,
+				claimToken: claim?.claimToken,
+				error: "retry later",
+			}),
+		).toBe(true);
+		const run = store.getRun(queued.runId);
+		expect(run?.status).toBe("queued");
+		expect(run?.claimToken).toBeUndefined();
+		expect(run?.startedAt).toBeUndefined();
+		expect(run?.error).toBe("retry later");
+	});
+});
+
+describe("SqliteCronStore: schedule spec fields", () => {
+	let dir: string;
+	let store: SqliteCronStore;
+
+	beforeEach(() => {
+		const tmp = tempDbPath();
+		dir = tmp.dir;
+		store = new SqliteCronStore({ dbPath: tmp.path });
+	});
+	afterEach(() => {
+		store.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("persists schedule_expr and timezone", () => {
+		const spec: CronScheduleSpec = {
+			triggerKind: "schedule",
+			id: "nightly",
+			title: "Nightly",
+			prompt: "p",
+			workspaceRoot: "/ws",
+			enabled: true,
+			schedule: "0 2 * * *",
+			timezone: "UTC",
+		};
+		const result = store.upsertSpec({
+			externalId: "nightly",
+			sourcePath: "nightly.cron.md",
+			triggerKind: "schedule",
+			sourceHash: "h",
+			parseStatus: "valid",
+			spec,
+		});
+		expect(result.record.scheduleExpr).toBe("0 2 * * *");
+		expect(result.record.timezone).toBe("UTC");
+	});
+});