selftune 0.2.23 → 0.2.24

package/cli/selftune/localdb/queries/evolution.ts

@@ -0,0 +1,158 @@
+import type { Database } from "bun:sqlite";
+
+import type { OrchestrateRunReport, PendingProposal } from "../../dashboard-contract.js";
+import { safeParseJson, safeParseJsonArray } from "./json.js";
+
+export function queryEvolutionAudit(
+  db: Database,
+  skillName?: string,
+): Array<{
+  timestamp: string;
+  proposal_id: string;
+  skill_name?: string;
+  action: string;
+  details: string;
+  eval_snapshot?: Record<string, unknown>;
+  validation_mode?: string;
+  validation_agent?: string;
+  validation_fixture_id?: string;
+  validation_evidence_ref?: string;
+}> {
+  const sql = skillName
+    ? `SELECT * FROM evolution_audit
+       WHERE skill_name = ?
+          OR (skill_name IS NULL AND proposal_id LIKE 'evo-' || ? || '-%')
+       ORDER BY timestamp DESC`
+    : `SELECT * FROM evolution_audit ORDER BY timestamp DESC`;
+  const rows = (skillName ? db.query(sql).all(skillName, skillName) : db.query(sql).all()) as Array<
+    Record<string, unknown>
+  >;
+
+  return rows.map((row) => ({
+    timestamp: row.timestamp as string,
+    proposal_id: row.proposal_id as string,
+    skill_name: typeof row.skill_name === "string" ? row.skill_name : undefined,
+    action: row.action as string,
+    details: row.details as string,
+    eval_snapshot: row.eval_snapshot_json
+      ? (safeParseJson(row.eval_snapshot_json as string) as Record<string, unknown>)
+      : undefined,
+    validation_mode: typeof row.validation_mode === "string" ? row.validation_mode : undefined,
+    validation_agent: typeof row.validation_agent === "string" ? row.validation_agent : undefined,
+    validation_fixture_id:
+      typeof row.validation_fixture_id === "string" ? row.validation_fixture_id : undefined,
+    validation_evidence_ref:
+      typeof row.validation_evidence_ref === "string" ? row.validation_evidence_ref : undefined,
+  }));
+}
+
+export function queryEvolutionEvidence(
+  db: Database,
+  skillName?: string,
+): Array<{
+  timestamp: string;
+  proposal_id: string;
+  skill_name: string;
+  skill_path: string;
+  target: string;
+  stage: string;
+  rationale?: string;
+  confidence?: number;
+  details?: string;
+  original_text?: string;
+  proposed_text?: string;
+  eval_set?: Record<string, unknown>[];
+  validation?: Record<string, unknown>;
+}> {
+  const sql = skillName
+    ? `SELECT * FROM evolution_evidence WHERE skill_name = ? ORDER BY timestamp DESC`
+    : `SELECT * FROM evolution_evidence ORDER BY timestamp DESC`;
+  const rows = (skillName ? db.query(sql).all(skillName) : db.query(sql).all()) as Array<
+    Record<string, unknown>
+  >;
+
+  return rows.map((row) => ({
+    timestamp: row.timestamp as string,
+    proposal_id: row.proposal_id as string,
+    skill_name: row.skill_name as string,
+    skill_path: row.skill_path as string,
+    target: row.target as string,
+    stage: row.stage as string,
+    rationale: row.rationale as string | undefined,
+    confidence: row.confidence as number | undefined,
+    details: row.details as string | undefined,
+    original_text: row.original_text as string | undefined,
+    proposed_text: row.proposed_text as string | undefined,
+    eval_set: row.eval_set_json
+      ? safeParseJsonArray<Record<string, unknown>>(row.eval_set_json as string)
+      : undefined,
+    validation: row.validation_json
+      ? (safeParseJson(row.validation_json as string) as Record<string, unknown>)
+      : undefined,
+  }));
+}
+
+export function getPendingProposals(db: Database, skillName?: string): PendingProposal[] {
+  const whereClause = skillName ? "WHERE ea.skill_name = ? AND" : "WHERE";
+  const params = skillName ? [skillName] : [];
+
+  return db
+    .query(
+      `WITH latest AS (
+         SELECT ea.proposal_id, ea.action, ea.timestamp, ea.details, ea.skill_name,
+                ROW_NUMBER() OVER (PARTITION BY ea.proposal_id ORDER BY ea.timestamp DESC, ea.id DESC) AS rn
+         FROM evolution_audit ea
+         LEFT JOIN evolution_audit ea2
+           ON ea2.proposal_id = ea.proposal_id
+           AND ea2.action IN ('deployed', 'rejected', 'rolled_back')
+         ${whereClause} ea.action IN ('created', 'validated')
+           AND ea2.id IS NULL
+       )
+       SELECT proposal_id, action, timestamp, details, skill_name
+       FROM latest
+       WHERE rn = 1
+       ORDER BY timestamp DESC`,
+    )
+    .all(...params) as PendingProposal[];
+}
+
+export function getOrchestrateRuns(db: Database, limit = 20): OrchestrateRunReport[] {
+  const rows = db
+    .query(
+      `SELECT run_id, timestamp, elapsed_ms, dry_run, approval_mode,
+              total_skills, evaluated, evolved, deployed, watched, skipped,
+              skill_actions_json
+       FROM orchestrate_runs
+       ORDER BY timestamp DESC
+       LIMIT ?`,
+    )
+    .all(limit) as Array<{
+    run_id: string;
+    timestamp: string;
+    elapsed_ms: number;
+    dry_run: number;
+    approval_mode: string;
+    total_skills: number;
+    evaluated: number;
+    evolved: number;
+    deployed: number;
+    watched: number;
+    skipped: number;
+    skill_actions_json: string;
+  }>;
+
+  return rows.map((row) => ({
+    run_id: row.run_id,
+    timestamp: row.timestamp,
+    elapsed_ms: row.elapsed_ms,
+    dry_run: row.dry_run === 1,
+    approval_mode: row.approval_mode as "auto" | "review",
+    total_skills: row.total_skills,
+    evaluated: row.evaluated,
+    evolved: row.evolved,
+    deployed: row.deployed,
+    watched: row.watched,
+    skipped: row.skipped,
+    skill_actions: safeParseJsonArray(row.skill_actions_json),
+  }));
+}

package/cli/selftune/localdb/queries/execution.ts

@@ -0,0 +1,133 @@
+import type { Database } from "bun:sqlite";
+
+import type { CommitRecord, CommitSummary, ExecutionMetrics } from "../../dashboard-contract.js";
+
+export function getExecutionMetrics(db: Database, sessionIds: string[]): ExecutionMetrics {
+  const empty: ExecutionMetrics = {
+    avg_files_changed: 0,
+    total_lines_added: 0,
+    total_lines_removed: 0,
+    total_cost_usd: 0,
+    avg_cost_usd: 0,
+    cached_input_tokens_total: 0,
+    reasoning_output_tokens_total: 0,
+    artifact_count: 0,
+    session_type_distribution: {},
+  };
+  if (sessionIds.length === 0) return empty;
+
+  const placeholders = sessionIds.map(() => "?").join(",");
+  const row = db
+    .query(
+      `SELECT
+         COALESCE(AVG(files_changed), 0) AS avg_files_changed,
+         COALESCE(SUM(lines_added), 0) AS total_lines_added,
+         COALESCE(SUM(lines_removed), 0) AS total_lines_removed,
+         COALESCE(SUM(cost_usd), 0) AS total_cost_usd,
+         COALESCE(AVG(cost_usd), 0) AS avg_cost_usd,
+         COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens_total,
+         COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens_total,
+         COALESCE(SUM(artifact_count), 0) AS artifact_count
+       FROM execution_facts
+       WHERE session_id IN (${placeholders})`,
+    )
+    .get(...sessionIds) as {
+    avg_files_changed: number;
+    total_lines_added: number;
+    total_lines_removed: number;
+    total_cost_usd: number;
+    avg_cost_usd: number;
+    cached_input_tokens_total: number;
+    reasoning_output_tokens_total: number;
+    artifact_count: number;
+  } | null;
+
+  const typeRows = db
+    .query(
+      `SELECT session_type, COUNT(*) AS count
+       FROM execution_facts
+       WHERE session_id IN (${placeholders}) AND session_type IS NOT NULL
+       GROUP BY session_type`,
+    )
+    .all(...sessionIds) as Array<{ session_type: string; count: number }>;
+
+  const session_type_distribution: Record<string, number> = {};
+  for (const rowEntry of typeRows) {
+    session_type_distribution[rowEntry.session_type] = rowEntry.count;
+  }
+
+  return {
+    avg_files_changed: row?.avg_files_changed ?? 0,
+    total_lines_added: row?.total_lines_added ?? 0,
+    total_lines_removed: row?.total_lines_removed ?? 0,
+    total_cost_usd: row?.total_cost_usd ?? 0,
+    avg_cost_usd: row?.avg_cost_usd ?? 0,
+    cached_input_tokens_total: row?.cached_input_tokens_total ?? 0,
+    reasoning_output_tokens_total: row?.reasoning_output_tokens_total ?? 0,
+    artifact_count: row?.artifact_count ?? 0,
+    session_type_distribution,
+  };
+}
+
+export function getSessionCommits(db: Database, sessionId: string): CommitRecord[] {
+  return db
+    .query(
+      `SELECT commit_sha, commit_title, branch, repo_remote, timestamp
+       FROM commit_tracking
+       WHERE session_id = ?
+       ORDER BY timestamp DESC`,
+    )
+    .all(sessionId) as CommitRecord[];
+}
+
+export function getSkillCommitSummary(db: Database, skillName: string): CommitSummary {
+  const empty: CommitSummary = {
+    total_commits: 0,
+    unique_branches: 0,
+    recent_commits: [],
+  };
+
+  const statsRow = db
+    .query(
+      `WITH skill_sessions AS (
+         SELECT DISTINCT session_id FROM skill_invocations WHERE skill_name = ?
+       )
+       SELECT
+         COUNT(*) AS total_commits,
+         COUNT(DISTINCT ct.branch) AS unique_branches
+       FROM commit_tracking ct
+       WHERE ct.session_id IN (SELECT session_id FROM skill_sessions)`,
+    )
+    .get(skillName) as { total_commits: number; unique_branches: number } | null;
+
+  if (!statsRow || statsRow.total_commits === 0) return empty;
+
+  const recentRows = db
+    .query(
+      `WITH skill_sessions AS (
+         SELECT DISTINCT session_id FROM skill_invocations WHERE skill_name = ?
+       )
+       SELECT ct.commit_sha, ct.commit_title, ct.branch, ct.timestamp
+       FROM commit_tracking ct
+       WHERE ct.session_id IN (SELECT session_id FROM skill_sessions)
+       ORDER BY ct.timestamp DESC
+       LIMIT 20`,
+    )
+    .all(skillName) as Array<{
+    commit_sha: string;
+    commit_title: string | null;
+    branch: string | null;
+    timestamp: string;
+  }>;
+
+  return {
+    total_commits: statsRow.total_commits,
+    unique_branches: statsRow.unique_branches,
+    recent_commits: recentRows.map((row) => ({
+      sha: row.commit_sha,
+      title: row.commit_title ?? "",
+      branch: row.branch ?? "",
+      timestamp: row.timestamp,
+    })),
+  };
+}

package/cli/selftune/localdb/queries/json.ts

@@ -0,0 +1,18 @@
+export function safeParseJsonArray<T = string>(json: string | null): T[] {
+  if (!json) return [];
+  try {
+    const parsed = JSON.parse(json);
+    return Array.isArray(parsed) ? (parsed as T[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function safeParseJson(json: string | null): Record<string, unknown> | null {
+  if (!json) return null;
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}

package/cli/selftune/localdb/queries/monitoring.ts

@@ -0,0 +1,263 @@
+import type { Database } from "bun:sqlite";
+
+export function queryImprovementSignals(
+  db: Database,
+  consumedOnly?: boolean,
+): Array<{
+  timestamp: string;
+  session_id: string;
+  query: string;
+  signal_type: string;
+  mentioned_skill?: string;
+  consumed: boolean;
+  consumed_at?: string;
+  consumed_by_run?: string;
+}> {
+  const where =
+    consumedOnly === undefined ? "" : consumedOnly ? " WHERE consumed = 1" : " WHERE consumed = 0";
+  const rows = db
+    .query(`SELECT * FROM improvement_signals${where} ORDER BY timestamp DESC`)
+    .all() as Array<Record<string, unknown>>;
+  return rows.map((row) => ({
+    timestamp: row.timestamp as string,
+    session_id: row.session_id as string,
+    query: row.query as string,
+    signal_type: row.signal_type as string,
+    mentioned_skill: row.mentioned_skill as string | undefined,
+    consumed: (row.consumed as number) === 1,
+    consumed_at: row.consumed_at as string | undefined,
+    consumed_by_run: row.consumed_by_run as string | undefined,
+  }));
+}
+
+export function queryGradingResults(db: Database): Array<{
+  grading_id: string;
+  session_id: string;
+  skill_name: string;
+  transcript_path: string | null;
+  graded_at: string;
+  pass_rate: number | null;
+  mean_score: number | null;
+  score_std_dev: number | null;
+  passed_count: number | null;
+  failed_count: number | null;
+  total_count: number | null;
+  expectations_json: string | null;
+  claims_json: string | null;
+  eval_feedback_json: string | null;
+  failure_feedback_json: string | null;
+  execution_metrics_json: string | null;
+}> {
+  return db
+    .query(
+      `SELECT grading_id, session_id, skill_name, transcript_path, graded_at,
+              pass_rate, mean_score, score_std_dev, passed_count, failed_count, total_count,
+              expectations_json, claims_json, eval_feedback_json, failure_feedback_json,
+              execution_metrics_json
+       FROM grading_results
+       ORDER BY graded_at DESC`,
+    )
+    .all() as Array<{
+    grading_id: string;
+    session_id: string;
+    skill_name: string;
+    transcript_path: string | null;
+    graded_at: string;
+    pass_rate: number | null;
+    mean_score: number | null;
+    score_std_dev: number | null;
+    passed_count: number | null;
+    failed_count: number | null;
+    total_count: number | null;
+    expectations_json: string | null;
+    claims_json: string | null;
+    eval_feedback_json: string | null;
+    failure_feedback_json: string | null;
+    execution_metrics_json: string | null;
+  }>;
+}
+
+export function queryReplayEntryResults(
+  db: Database,
+  proposalId: string,
+  phase?: string,
+): Array<{
+  id: number;
+  proposal_id: string;
+  skill_name: string;
+  validation_mode: string;
+  phase: string;
+  query: string;
+  should_trigger: boolean;
+  triggered: boolean;
+  passed: boolean;
+  evidence: string | null;
+}> {
+  const sql = phase
+    ? `SELECT id, proposal_id, skill_name, validation_mode, phase, query,
+              should_trigger, triggered, passed, evidence
+       FROM replay_entry_results
+       WHERE proposal_id = ? AND phase = ?
+       ORDER BY id`
+    : `SELECT id, proposal_id, skill_name, validation_mode, phase, query,
+              should_trigger, triggered, passed, evidence
+       FROM replay_entry_results
+       WHERE proposal_id = ?
+       ORDER BY id`;
+
+  const rows = phase
+    ? (db.query(sql).all(proposalId, phase) as Array<Record<string, unknown>>)
+    : (db.query(sql).all(proposalId) as Array<Record<string, unknown>>);
+
+  return rows.map((row) => ({
+    id: row.id as number,
+    proposal_id: row.proposal_id as string,
+    skill_name: row.skill_name as string,
+    validation_mode: row.validation_mode as string,
+    phase: row.phase as string,
+    query: row.query as string,
+    should_trigger: (row.should_trigger as number) === 1,
+    triggered: (row.triggered as number) === 1,
+    passed: (row.passed as number) === 1,
+    evidence: row.evidence as string | null,
+  }));
+}
+
+export function queryReplayRegressions(
+  db: Database,
+  proposalId: string,
+): Array<{
+  query: string;
+  skill_name: string;
+  before_passed: boolean;
+  after_passed: boolean;
+}> {
+  const rows = db
+    .query(
+      `SELECT b.query, b.skill_name,
+              b.passed AS before_passed,
+              a.passed AS after_passed
+       FROM replay_entry_results b
+       JOIN replay_entry_results a
+         ON b.proposal_id = a.proposal_id
+         AND b.query = a.query
+         AND b.skill_name = a.skill_name
+       WHERE b.proposal_id = ?
+         AND b.phase = 'before'
+         AND a.phase = 'after'
+         AND b.passed = 1
+         AND a.passed = 0
+       ORDER BY b.query`,
+    )
+    .all(proposalId) as Array<Record<string, unknown>>;
+
+  return rows.map((row) => ({
+    query: row.query as string,
+    skill_name: row.skill_name as string,
+    before_passed: (row.before_passed as number) === 1,
+    after_passed: (row.after_passed as number) === 1,
+  }));
+}
+
+export interface GradingBaselineRow {
+  id: number;
+  skill_name: string;
+  proposal_id: string | null;
+  measured_at: string;
+  pass_rate: number;
+  mean_score: number | null;
+  sample_size: number;
+  grading_results_json: string | null;
+}
+
+export interface GradeRegressionResult {
+  before: GradingBaselineRow;
+  after: GradingBaselineRow;
+  delta_pass_rate: number;
+  delta_mean_score: number | null;
+  regressed: boolean;
+}
+
+export function queryGradingBaseline(
+  db: Database,
+  skillName: string,
+  proposalId?: string,
+): GradingBaselineRow | null {
+  if (proposalId !== undefined) {
+    return (
+      (db
+        .query(
+          `SELECT * FROM grading_baselines
+           WHERE skill_name = ? AND proposal_id = ?
+           ORDER BY measured_at DESC
+           LIMIT 1`,
+        )
+        .get(skillName, proposalId) as GradingBaselineRow | null) ?? null
+    );
+  }
+
+  return (
+    (db
+      .query(
+        `SELECT * FROM grading_baselines
+         WHERE skill_name = ? AND proposal_id IS NULL
+         ORDER BY measured_at DESC
+         LIMIT 1`,
+      )
+      .get(skillName) as GradingBaselineRow | null) ?? null
+  );
+}
+
+export function queryGradeRegression(
+  db: Database,
+  skillName: string,
+  afterProposalId: string,
+  beforeProposalId?: string,
+): GradeRegressionResult | null {
+  const before = queryGradingBaseline(db, skillName, beforeProposalId);
+  const after = queryGradingBaseline(db, skillName, afterProposalId);
+  if (!before || !after) return null;
+
+  const deltaPR = after.pass_rate - before.pass_rate;
+  const deltaMS =
+    after.mean_score != null && before.mean_score != null
+      ? after.mean_score - before.mean_score
+      : null;
+
+  return {
+    before,
+    after,
+    delta_pass_rate: deltaPR,
+    delta_mean_score: deltaMS,
+    regressed: deltaPR < 0,
+  };
+}
+
+export interface RecentGradingResultRow {
+  grading_id: string;
+  session_id: string;
+  skill_name: string;
+  graded_at: string;
+  pass_rate: number | null;
+  mean_score: number | null;
+  total_count: number | null;
+  passed_count: number | null;
+  failed_count: number | null;
+}
+
+export function queryRecentGradingResults(
+  db: Database,
+  skillName: string,
+  limit: number = 20,
+): RecentGradingResultRow[] {
+  return db
+    .query(
+      `SELECT grading_id, session_id, skill_name, graded_at,
+              pass_rate, mean_score, total_count, passed_count, failed_count
+       FROM grading_results
+       WHERE skill_name = ?
+       ORDER BY graded_at DESC
+       LIMIT ?`,
+    )
+    .all(skillName, limit) as RecentGradingResultRow[];
+}

package/cli/selftune/localdb/queries/raw.ts

@@ -0,0 +1,95 @@
+import type { Database } from "bun:sqlite";
+
+import type { SkillUsageRecord } from "../../types.js";
+import { safeParseJson, safeParseJsonArray } from "./json.js";
+
+export function querySessionTelemetry(
+  db: Database,
+  limit?: number,
+): Array<{
+  timestamp: string;
+  session_id: string;
+  cwd: string;
+  transcript_path: string;
+  tool_calls: Record<string, number>;
+  total_tool_calls: number;
+  bash_commands: string[];
+  skills_triggered: string[];
+  skills_invoked?: string[];
+  assistant_turns: number;
+  errors_encountered: number;
+  transcript_chars: number;
+  last_user_query: string;
+  source?: string;
+  input_tokens?: number;
+  output_tokens?: number;
+}> {
+  const sql =
+    limit != null
+      ? `SELECT * FROM session_telemetry ORDER BY timestamp DESC LIMIT ${limit}`
+      : `SELECT * FROM session_telemetry ORDER BY timestamp DESC`;
+  const rows = db.query(sql).all() as Array<Record<string, unknown>>;
+  return rows.map((row) => ({
+    timestamp: row.timestamp as string,
+    session_id: row.session_id as string,
+    cwd: row.cwd as string,
+    transcript_path: row.transcript_path as string,
+    tool_calls: (safeParseJson(row.tool_calls_json as string) as Record<string, number>) ?? {},
+    total_tool_calls: row.total_tool_calls as number,
+    bash_commands: safeParseJsonArray<string>(row.bash_commands_json as string),
+    skills_triggered: safeParseJsonArray<string>(row.skills_triggered_json as string),
+    skills_invoked: row.skills_invoked_json
+      ? safeParseJsonArray<string>(row.skills_invoked_json as string)
+      : undefined,
+    assistant_turns: row.assistant_turns as number,
+    errors_encountered: row.errors_encountered as number,
+    transcript_chars: (row.transcript_chars as number) ?? 0,
+    last_user_query: (row.last_user_query as string) ?? "",
+    source: row.source as string | undefined,
+    input_tokens: row.input_tokens as number | undefined,
+    output_tokens: row.output_tokens as number | undefined,
+  }));
+}
+
+export function querySkillRecords(db: Database, limit?: number): SkillUsageRecord[] {
+  const sql =
+    limit != null
+      ? `SELECT occurred_at, session_id, skill_name, skill_path, skill_scope, query, triggered, source
+     FROM skill_invocations ORDER BY occurred_at DESC LIMIT ${limit}`
+      : `SELECT occurred_at, session_id, skill_name, skill_path, skill_scope, query, triggered, source
+     FROM skill_invocations ORDER BY occurred_at DESC`;
+  const rows = db.query(sql).all() as Array<Record<string, unknown>>;
+  return rows.map((row) => ({
+    timestamp: row.occurred_at as string,
+    session_id: row.session_id as string,
+    skill_name: row.skill_name as string,
+    skill_path: row.skill_path as string,
+    skill_scope: row.skill_scope as SkillUsageRecord["skill_scope"],
+    query: row.query as string,
+    triggered: (row.triggered as number) === 1,
+    source: row.source as string | undefined,
+  }));
+}
+
+export const querySkillUsageRecords = querySkillRecords;
+
+export function queryQueryLog(
+  db: Database,
+  limit?: number,
+): Array<{
+  timestamp: string;
+  session_id: string;
+  query: string;
+  source?: string;
+}> {
+  const sql =
+    limit != null
+      ? `SELECT timestamp, session_id, query, source FROM queries ORDER BY timestamp DESC LIMIT ${limit}`
+      : `SELECT timestamp, session_id, query, source FROM queries ORDER BY timestamp DESC`;
+  return db.query(sql).all() as Array<{
+    timestamp: string;
+    session_id: string;
+    query: string;
+    source?: string;
+  }>;
+}