@sdods/db 0.2.0

package/dist/repos/improvement.js

@@ -0,0 +1,242 @@
+import { sql } from 'kysely';
+import { enc, nowIso, readBool, readJson, readTs } from '../col.js';
+import { newId } from '../ids.js';
+export async function insertHealEvent(db, driver, input) {
+    const id = newId();
+    const e = input.event;
+    await db
+        .insertInto('heal_events')
+        .values({
+        id,
+        project_id: input.projectId,
+        run_id: input.runId,
+        scenario_id: input.scenarioId ?? null,
+        attempt_id: input.attemptId ?? null,
+        step_id: input.stepId ?? null,
+        page_url: e.pageUrl ?? null,
+        original_selector: e.originalSelector,
+        context_json: enc.json(e.context ?? {}),
+        strategy_used: e.strategyUsed ?? null,
+        healed_selector: e.healedSelector ?? null,
+        candidates_json: enc.json(e.candidates ?? []),
+        succeeded: enc.bool(driver, e.succeeded),
+        duration_ms: e.durationMs ?? null,
+        source: input.source ?? 'runtime',
+        accepted: null,
+        accepted_by: null,
+        created_at: e.at ?? nowIso(),
+    })
+        .execute();
+    return id;
+}
+/** Increment counters for one selector (upsert on project_id + selector). */
+export async function bumpLocatorStats(db, projectId, d) {
+    const at = d.at ?? nowIso();
+    const existing = await db
+        .selectFrom('locator_stats')
+        .select(['id'])
+        .where('project_id', '=', projectId)
+        .where('selector', '=', d.selector)
+        .executeTakeFirst();
+    const fails = d.fails ?? 0;
+    const heals = d.heals ?? 0;
+    const uses = d.uses ?? 0;
+    if (existing) {
+        await db
+            .updateTable('locator_stats')
+            .set((eb) => ({
+            fail_count: eb('fail_count', '+', fails),
+            heal_count: eb('heal_count', '+', heals),
+            use_count: eb('use_count', '+', uses),
+            ...(fails > 0 ? { last_failed_at: at } : {}),
+            ...(heals > 0 ? { last_healed_at: at } : {}),
+            ...(d.lastStrategy ? { last_strategy: d.lastStrategy } : {}),
+            ...(d.suggestedSelector ? { suggested_selector: d.suggestedSelector } : {}),
+            ...(d.pageHint ? { page_hint: d.pageHint } : {}),
+            updated_at: at,
+        }))
+            .where('id', '=', existing.id)
+            .execute();
+        return;
+    }
+    await db
+        .insertInto('locator_stats')
+        .values({
+        id: newId(),
+        project_id: projectId,
+        selector: d.selector,
+        page_hint: d.pageHint ?? null,
+        fail_count: fails,
+        heal_count: heals,
+        use_count: uses,
+        last_failed_at: fails > 0 ? at : null,
+        last_healed_at: heals > 0 ? at : null,
+        last_strategy: d.lastStrategy ?? null,
+        suggested_selector: d.suggestedSelector ?? null,
+        updated_at: at,
+    })
+        .execute();
+}
+export async function listLocatorStats(db, projectId, limit = 50) {
+    const rows = await db
+        .selectFrom('locator_stats')
+        .selectAll()
+        .where('project_id', '=', projectId)
+        .orderBy('fail_count', 'desc')
+        .orderBy('heal_count', 'desc')
+        .limit(limit)
+        .execute();
+    return rows.map((r) => ({
+        id: r.id,
+        selector: r.selector,
+        pageHint: r.page_hint,
+        failCount: r.fail_count,
+        healCount: r.heal_count,
+        useCount: r.use_count,
+        lastFailedAt: readTs(r.last_failed_at),
+        lastHealedAt: readTs(r.last_healed_at),
+        lastStrategy: r.last_strategy,
+        suggestedSelector: r.suggested_selector,
+    }));
+}
+export async function listHealEvents(db, opts) {
+    let q = db
+        .selectFrom('heal_events')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .limit(opts.limit ?? 100);
+    if (opts.projectId)
+        q = q.where('project_id', '=', opts.projectId);
+    if (opts.runId)
+        q = q.where('run_id', '=', opts.runId);
+    const rows = await q.execute();
+    return rows.map((h) => ({
+        id: h.id,
+        runId: h.run_id,
+        scenarioId: h.scenario_id,
+        pageUrl: h.page_url,
+        originalSelector: h.original_selector,
+        context: readJson(h.context_json) ?? {},
+        strategyUsed: h.strategy_used,
+        healedSelector: h.healed_selector,
+        candidates: readJson(h.candidates_json) ?? [],
+        succeeded: readBool(h.succeeded),
+        durationMs: h.duration_ms,
+        createdAt: readTs(h.created_at),
+    }));
+}
+/**
+ * Recompute flaky stats for one (project, fingerprint, runner_project) over the last `window` runs.
+ */
+export async function recomputeFlakyStats(db, driver, input) {
+    const window = input.window ?? 20;
+    const rows = await db
+        .selectFrom('scenarios')
+        .innerJoin('runs', 'runs.id', 'scenarios.run_id')
+        .select([
+        'scenarios.status as status',
+        'scenarios.flaky as flaky',
+        'scenarios.run_id as run_id',
+        'scenarios.feature_uri as feature_uri',
+        'scenarios.scenario_name as scenario_name',
+        'scenarios.finished_at as finished_at',
+        'runs.started_at as run_started_at',
+        'runs.created_at as run_created_at',
+    ])
+        .where('scenarios.project_id', '=', input.projectId)
+        .where('scenarios.fingerprint', '=', input.fingerprint)
+        .where('scenarios.runner_project', '=', input.runnerProject)
+        .orderBy(sql `coalesce(runs.started_at, runs.created_at)`, 'desc')
+        .limit(window)
+        .execute();
+    if (rows.length === 0)
+        return;
+    const runsCount = rows.length;
+    const passCount = rows.filter((r) => r.status === 'passed' && !readBool(r.flaky)).length;
+    const failCount = rows.filter((r) => r.status === 'failed' || r.status === 'timedOut').length;
+    const flakyCount = rows.filter((r) => readBool(r.flaky)).length;
+    const flakyRate = (flakyCount + failCount) / runsCount;
+    let failStreak = 0;
+    for (const r of rows) {
+        if (r.status === 'failed' || r.status === 'timedOut')
+            failStreak++;
+        else
+            break;
+    }
+    const last = rows[0];
+    const lastFailed = rows.find((r) => r.status === 'failed' || r.status === 'timedOut');
+    const existing = await db
+        .selectFrom('flaky_stats')
+        .select(['id'])
+        .where('project_id', '=', input.projectId)
+        .where('fingerprint', '=', input.fingerprint)
+        .where('runner_project', '=', input.runnerProject)
+        .executeTakeFirst();
+    const values = {
+        feature_uri: last.feature_uri,
+        scenario_name: last.scenario_name,
+        window_size: window,
+        runs_count: runsCount,
+        pass_count: passCount,
+        fail_count: failCount,
+        flaky_count: flakyCount,
+        flaky_rate: Number(flakyRate.toFixed(4)),
+        fail_streak: failStreak,
+        last_status: last.status,
+        last_run_id: last.run_id,
+        last_failed_at: lastFailed ? readTs(lastFailed.finished_at) : null,
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('flaky_stats').set(values).where('id', '=', existing.id).execute();
+    }
+    else {
+        await db
+            .insertInto('flaky_stats')
+            .values({
+            id: newId(),
+            project_id: input.projectId,
+            fingerprint: input.fingerprint,
+            runner_project: input.runnerProject,
+            quarantined: enc.bool(driver, false),
+            ...values,
+        })
+            .execute();
+    }
+}
+export async function listFlakyStats(db, projectId, limit = 50) {
+    const rows = await db
+        .selectFrom('flaky_stats')
+        .selectAll()
+        .where('project_id', '=', projectId)
+        .orderBy('flaky_rate', 'desc')
+        .orderBy('fail_streak', 'desc')
+        .limit(limit)
+        .execute();
+    return rows.map((r) => ({
+        id: r.id,
+        fingerprint: r.fingerprint,
+        runnerProject: r.runner_project,
+        featureUri: r.feature_uri,
+        scenarioName: r.scenario_name,
+        windowSize: r.window_size,
+        runsCount: r.runs_count,
+        passCount: r.pass_count,
+        failCount: r.fail_count,
+        flakyCount: r.flaky_count,
+        flakyRate: Number(r.flaky_rate),
+        failStreak: r.fail_streak,
+        lastStatus: r.last_status,
+        lastRunId: r.last_run_id,
+        lastFailedAt: readTs(r.last_failed_at),
+        quarantined: readBool(r.quarantined),
+    }));
+}
+export async function setQuarantine(db, driver, id, quarantined) {
+    await db
+        .updateTable('flaky_stats')
+        .set({ quarantined: enc.bool(driver, quarantined), updated_at: nowIso() })
+        .where('id', '=', id)
+        .execute();
+}
+//# sourceMappingURL=improvement.js.map

package/dist/repos/index.d.ts

@@ -0,0 +1,8 @@
+export * from './projects.js';
+export * from './runs.js';
+export * from './improvement.js';
+export * from './test-data.js';
+export * from './auth.js';
+export * from './platform.js';
+export * from './hierarchy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/repos/index.js

@@ -0,0 +1,8 @@
+export * from './projects.js';
+export * from './runs.js';
+export * from './improvement.js';
+export * from './test-data.js';
+export * from './auth.js';
+export * from './platform.js';
+export * from './hierarchy.js';
+//# sourceMappingURL=index.js.map

package/dist/repos/platform.d.ts

@@ -0,0 +1,250 @@
+import type { Kysely } from 'kysely';
+import type { Driver } from '../driver.js';
+import type { Database } from '../schema.js';
+export declare function upsertIntegration(db: Kysely<Database>, driver: Driver, input: {
+    projectId: string;
+    provider: string;
+    config: Record<string, unknown>;
+    secretEnv?: Record<string, string>;
+    enabled?: boolean;
+}): Promise<string>;
+export declare function listIntegrations(db: Kysely<Database>, projectId: string): Promise<{
+    id: string;
+    provider: string;
+    config: Record<string, unknown>;
+    secretEnv: Record<string, string>;
+    enabled: boolean;
+    lastSyncAt: string | null;
+}[]>;
+export declare function upsertIssueLink(db: Kysely<Database>, input: {
+    projectId: string;
+    integrationId?: string | null;
+    provider: string;
+    fingerprint: string;
+    scenarioName?: string | null;
+    externalKey: string;
+    externalUrl?: string | null;
+    status?: string;
+    source?: string;
+    lastRunId?: string | null;
+}): Promise<string>;
+export declare function findOpenIssueLink(db: Kysely<Database>, projectId: string, provider: string, fingerprint: string): Promise<{
+    id: any;
+    projectId: any;
+    integrationId: any;
+    provider: any;
+    fingerprint: any;
+    scenarioName: any;
+    externalKey: any;
+    externalUrl: any;
+    status: any;
+    source: any;
+    lastRunId: any;
+    lastSyncedAt: string | null;
+} | null>;
+export declare function listIssueLinks(db: Kysely<Database>, opts: {
+    projectId?: string;
+    fingerprint?: string;
+    provider?: string;
+}): Promise<{
+    id: any;
+    projectId: any;
+    integrationId: any;
+    provider: any;
+    fingerprint: any;
+    scenarioName: any;
+    externalKey: any;
+    externalUrl: any;
+    status: any;
+    source: any;
+    lastRunId: any;
+    lastSyncedAt: string | null;
+}[]>;
+export declare function setIssueLinkStatus(db: Kysely<Database>, id: string, status: string): Promise<void>;
+export declare function upsertProposal(db: Kysely<Database>, input: {
+    id: string;
+    projectId: string;
+    role: string;
+    status?: string;
+    summary?: string | null;
+    manifest: Record<string, unknown>;
+    costUsd?: number | null;
+    model?: string | null;
+    createdBy?: string | null;
+}): Promise<void>;
+export declare function reviewProposal(db: Kysely<Database>, id: string, status: 'accepted' | 'rejected', reviewedBy?: string | null): Promise<void>;
+export declare function listProposals(db: Kysely<Database>, opts?: {
+    projectId?: string;
+    status?: string;
+    limit?: number;
+}): Promise<{
+    id: string;
+    projectId: string;
+    role: string;
+    status: string;
+    summary: string | null;
+    manifest: Record<string, unknown>;
+    costUsd: number | null;
+    model: string | null;
+    createdBy: string | null;
+    reviewedBy: string | null;
+    createdAt: string | null;
+    reviewedAt: string | null;
+}[]>;
+export declare function createAgentJob(db: Kysely<Database>, input: {
+    projectId: string;
+    kind: string;
+    goal?: string | null;
+    input?: Record<string, unknown>;
+    provider?: string | null;
+    model?: string | null;
+    startedBy?: string | null;
+}): Promise<string>;
+export declare function updateAgentJob(db: Kysely<Database>, id: string, patch: Partial<{
+    status: string;
+    output: Record<string, unknown>;
+    diffText: string | null;
+    logRel: string | null;
+    tokensIn: number;
+    tokensOut: number;
+    costUsd: number;
+    turns: number;
+    proposalId: string | null;
+    startedAt: string;
+    finishedAt: string;
+    error: string | null;
+    reviewedBy: string | null;
+    reviewedAt: string;
+}>): Promise<void>;
+export declare function getAgentJob(db: Kysely<Database>, id: string): Promise<{
+    id: any;
+    projectId: any;
+    kind: any;
+    goal: any;
+    status: any;
+    input: Record<string, unknown>;
+    output: Record<string, unknown> | null;
+    diffText: any;
+    logRel: any;
+    provider: any;
+    model: any;
+    tokensIn: any;
+    tokensOut: any;
+    costUsd: any;
+    turns: any;
+    proposalId: any;
+    startedBy: any;
+    startedAt: string | null;
+    finishedAt: string | null;
+    error: any;
+    createdAt: string | null;
+} | null>;
+export declare function listAgentJobs(db: Kysely<Database>, opts?: {
+    projectId?: string;
+    status?: string;
+    limit?: number;
+}): Promise<{
+    id: any;
+    projectId: any;
+    kind: any;
+    goal: any;
+    status: any;
+    input: Record<string, unknown>;
+    output: Record<string, unknown> | null;
+    diffText: any;
+    logRel: any;
+    provider: any;
+    model: any;
+    tokensIn: any;
+    tokensOut: any;
+    costUsd: any;
+    turns: any;
+    proposalId: any;
+    startedBy: any;
+    startedAt: string | null;
+    finishedAt: string | null;
+    error: any;
+    createdAt: string | null;
+}[]>;
+export interface ScheduleUpsert {
+    projectId: string;
+    environmentId?: string | null;
+    name: string;
+    cronExpr: string;
+    timezone?: string;
+    runInput: Record<string, unknown>;
+    overlapPolicy?: string;
+    jitterSeconds?: number;
+    catchUp?: boolean;
+    enabled?: boolean;
+    notify?: unknown;
+    retentionRuns?: number | null;
+    nextRunAt?: string | null;
+    createdBy?: string | null;
+}
+export declare function upsertSchedule(db: Kysely<Database>, driver: Driver, s: ScheduleUpsert): Promise<string>;
+export declare function listSchedules(db: Kysely<Database>, projectId?: string): Promise<{
+    id: string;
+    projectId: string;
+    environmentId: string | null;
+    name: string;
+    cronExpr: string;
+    timezone: string;
+    runInput: Record<string, unknown>;
+    overlapPolicy: string;
+    jitterSeconds: number;
+    catchUp: boolean;
+    enabled: boolean;
+    notify: {};
+    retentionRuns: number | null;
+    nextRunAt: string | null;
+    lastRunId: string | null;
+    lastStatus: string | null;
+}[]>;
+export declare function updateScheduleState(db: Kysely<Database>, id: string, patch: {
+    nextRunAt?: string | null;
+    lastRunId?: string | null;
+    lastStatus?: string | null;
+    enabled?: boolean;
+}, driver: Driver): Promise<void>;
+export declare function deleteSchedule(db: Kysely<Database>, id: string): Promise<void>;
+export declare function recordScheduleRun(db: Kysely<Database>, input: {
+    scheduleId: string;
+    runId?: string | null;
+    status: string;
+    note?: string | null;
+}): Promise<void>;
+export declare function listScheduleRuns(db: Kysely<Database>, scheduleId: string, limit?: number): Promise<{
+    id: string;
+    status: string;
+    run_id: string | null;
+    schedule_id: string;
+    fired_at: string;
+    note: string | null;
+}[]>;
+export declare function audit(db: Kysely<Database>, input: {
+    actorUserId?: string | null;
+    actorType?: 'user' | 'cli' | 'system' | 'token';
+    action: string;
+    targetType?: string | null;
+    targetId?: string | null;
+    details?: Record<string, unknown>;
+    ip?: string | null;
+}): Promise<void>;
+export declare function listAudit(db: Kysely<Database>, opts?: {
+    limit?: number;
+    before?: string;
+}): Promise<{
+    details: unknown;
+    createdAt: string | null;
+    id: string;
+    created_at: string;
+    ip: string | null;
+    actor_user_id: string | null;
+    actor_type: string;
+    action: string;
+    target_type: string | null;
+    target_id: string | null;
+    details_json: Record<string, unknown> | null;
+}[]>;
+//# sourceMappingURL=platform.d.ts.map