neondeck 1.0.0-beta.4

package/src/modules/worktrees/store.ts

@@ -0,0 +1,414 @@
+import { randomUUID } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
+import * as v from 'valibot';
+import type { RepoConfig, RuntimePaths } from '../../runtime-home';
+import { WorktreeError, errorMessage } from './errors';
+import { cleanupPolicy, repoFullName } from './paths';
+import {
+  cleanupAttemptRowSchema,
+  lifecycleStatusSchema,
+  lockRowSchema,
+  type WorktreeCleanupPolicy,
+  type WorktreeLifecycleStatus,
+  type WorktreeLockRecord,
+  type WorktreeRecord,
+  type WorktreeStorageKind,
+  worktreeCleanupPolicySchema,
+  worktreeRowSchema,
+} from './schemas';
+
+export function recordWorktreeCreating(
+  input: {
+    id: string;
+    repo: RepoConfig;
+    prNumber: number | null;
+    baseRef: string;
+    headOwner: string;
+    headName: string;
+    headRef: string;
+    headSha: string | null;
+    localPath: string;
+    storageKind: WorktreeStorageKind;
+    workflowRunId: string | null;
+    cleanupPolicy: WorktreeCleanupPolicy;
+    directPushAllowed: boolean;
+    adopted: boolean;
+    createdBy: string;
+    now: string;
+  },
+  paths: RuntimePaths,
+) {
+  upsertWorktree(
+    {
+      id: input.id,
+      repoId: input.repo.id,
+      repoFullName: repoFullName(input.repo),
+      githubOwner: input.repo.github.owner,
+      githubName: input.repo.github.name,
+      prNumber: input.prNumber,
+      baseRef: input.baseRef,
+      headOwner: input.headOwner,
+      headName: input.headName,
+      headRef: input.headRef,
+      headSha: input.headSha,
+      localPath: input.localPath,
+      storageKind: input.storageKind,
+      owningWorkflowRunId: input.workflowRunId,
+      lifecycleStatus: 'creating',
+      lastSyncedSha: null,
+      lastPushedSha: null,
+      cleanupPolicy: input.cleanupPolicy,
+      directPushAllowed: input.directPushAllowed,
+      adopted: input.adopted,
+      createdBy: input.createdBy,
+      createdAt: input.now,
+      updatedAt: input.now,
+    },
+    paths,
+  );
+}
+
+export function upsertWorktree(record: WorktreeRecord, paths: RuntimePaths) {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+  try {
+    database
+      .prepare(
+        `
+        INSERT INTO worktrees (
+          id, repo_id, repo_full_name, github_owner, github_name, pr_number,
+          base_ref, head_owner, head_name, head_ref, head_sha, local_path,
+          storage_kind, owning_workflow_run_id, lifecycle_status,
+          last_synced_sha, last_pushed_sha, cleanup_policy_json,
+          direct_push_allowed, adopted, created_by, created_at, updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          repo_id = excluded.repo_id,
+          repo_full_name = excluded.repo_full_name,
+          github_owner = excluded.github_owner,
+          github_name = excluded.github_name,
+          pr_number = excluded.pr_number,
+          base_ref = excluded.base_ref,
+          head_owner = excluded.head_owner,
+          head_name = excluded.head_name,
+          head_ref = excluded.head_ref,
+          head_sha = excluded.head_sha,
+          local_path = excluded.local_path,
+          storage_kind = excluded.storage_kind,
+          owning_workflow_run_id = excluded.owning_workflow_run_id,
+          lifecycle_status = excluded.lifecycle_status,
+          last_synced_sha = excluded.last_synced_sha,
+          last_pushed_sha = excluded.last_pushed_sha,
+          cleanup_policy_json = excluded.cleanup_policy_json,
+          direct_push_allowed = excluded.direct_push_allowed,
+          adopted = excluded.adopted,
+          created_by = excluded.created_by,
+          updated_at = excluded.updated_at;
+      `,
+      )
+      .run(
+        record.id,
+        record.repoId,
+        record.repoFullName,
+        record.githubOwner,
+        record.githubName,
+        record.prNumber,
+        record.baseRef,
+        record.headOwner,
+        record.headName,
+        record.headRef,
+        record.headSha,
+        record.localPath,
+        record.storageKind,
+        record.owningWorkflowRunId,
+        record.lifecycleStatus,
+        record.lastSyncedSha,
+        record.lastPushedSha,
+        JSON.stringify(record.cleanupPolicy),
+        record.directPushAllowed ? 1 : 0,
+        record.adopted ? 1 : 0,
+        record.createdBy,
+        record.createdAt,
+        record.updatedAt,
+      );
+  } finally {
+    database.close();
+  }
+}
+
+export function updateWorktreeStatus(
+  id: string,
+  status: WorktreeLifecycleStatus,
+  paths: RuntimePaths,
+) {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+  try {
+    database
+      .prepare(
+        `
+        UPDATE worktrees
+        SET lifecycle_status = ?, updated_at = ?
+        WHERE id = ?;
+      `,
+      )
+      .run(status, new Date().toISOString(), id);
+  } finally {
+    database.close();
+  }
+}
+
+export async function recordWorktreeEvent(
+  worktreeId: string,
+  repoId: string,
+  eventType: string,
+  status: WorktreeLifecycleStatus,
+  message: string,
+  data: unknown,
+  paths: RuntimePaths,
+) {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+  try {
+    database
+      .prepare(
+        `
+        INSERT INTO worktree_events (
+          id, worktree_id, repo_id, event_type, status, message, data_json, created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?);
+      `,
+      )
+      .run(
+        randomUUID(),
+        worktreeId,
+        repoId,
+        eventType,
+        status,
+        message,
+        data === undefined ? null : JSON.stringify(data),
+        new Date().toISOString(),
+      );
+  } finally {
+    database.close();
+  }
+}
+
+export function recordCleanupAttempt(
+  record: WorktreeRecord,
+  outcome: string,
+  reason: string,
+  deleted: boolean,
+  error: string | undefined,
+  paths: RuntimePaths,
+) {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+  try {
+    database
+      .prepare(
+        `
+        INSERT INTO worktree_cleanup_attempts (
+          id, worktree_id, repo_id, action, outcome, reason, error, deleted, attempted_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
+      `,
+      )
+      .run(
+        randomUUID(),
+        record.id,
+        record.repoId,
+        'cleanup',
+        outcome,
+        reason,
+        error ?? null,
+        deleted ? 1 : 0,
+        new Date().toISOString(),
+      );
+  } finally {
+    database.close();
+  }
+}
+
+export function findReusableWorktree(
+  repoId: string,
+  prNumber: number | null,
+  headRef: string,
+  paths: RuntimePaths,
+) {
+  const database = new DatabaseSync(paths.neondeckDatabase, { readOnly: true });
+  try {
+    const row = database
+      .prepare(
+        `
+        SELECT *
+        FROM worktrees
+        WHERE repo_id = ?
+          AND COALESCE(pr_number, -1) = COALESCE(?, -1)
+          AND head_ref = ?
+          AND lifecycle_status != 'deleted'
+        ORDER BY updated_at DESC
+        LIMIT 1;
+      `,
+      )
+      .get(repoId, prNumber, headRef);
+    return row ? readWorktreeRow(row) : undefined;
+  } finally {
+    database.close();
+  }
+}
+
+export function requireWorktree(id: string, paths: RuntimePaths) {
+  const database = new DatabaseSync(paths.neondeckDatabase, { readOnly: true });
+  try {
+    const row = database
+      .prepare('SELECT * FROM worktrees WHERE id = ?;')
+      .get(id);
+    if (!row) {
+      throw new WorktreeError(
+        'WORKTREE_NOT_FOUND',
+        `Worktree ${id} was not found.`,
+      );
+    }
+    return readWorktreeRow(row);
+  } finally {
+    database.close();
+  }
+}
+
+export function listWorktreeRecords(paths: RuntimePaths) {
+  const database = new DatabaseSync(paths.neondeckDatabase, { readOnly: true });
+  try {
+    return database
+      .prepare(
+        `
+        SELECT *
+        FROM worktrees
+        ORDER BY updated_at DESC, created_at DESC;
+      `,
+      )
+      .all()
+      .map(readWorktreeRow);
+  } finally {
+    database.close();
+  }
+}
+
+export function listCleanupFailures(paths: RuntimePaths) {
+  const database = new DatabaseSync(paths.neondeckDatabase, { readOnly: true });
+  try {
+    return database
+      .prepare(
+        `
+        SELECT *
+        FROM worktree_cleanup_attempts
+        WHERE outcome = 'failed'
+        ORDER BY attempted_at DESC
+        LIMIT 50;
+      `,
+      )
+      .all()
+      .map(readCleanupAttemptRow);
+  } finally {
+    database.close();
+  }
+}
+
+export function readWorktreeRow(row: unknown): WorktreeRecord {
+  const item = parseDatabaseRow(worktreeRowSchema, row, 'worktree');
+  return {
+    id: item.id,
+    repoId: item.repo_id,
+    repoFullName: item.repo_full_name,
+    githubOwner: item.github_owner,
+    githubName: item.github_name,
+    prNumber: item.pr_number,
+    baseRef: item.base_ref,
+    headOwner: item.head_owner,
+    headName: item.head_name,
+    headRef: item.head_ref,
+    headSha: item.head_sha,
+    localPath: item.local_path,
+    storageKind: item.storage_kind === 'repo-local' ? 'repo-local' : 'home',
+    owningWorkflowRunId: item.owning_workflow_run_id,
+    lifecycleStatus: normalizeStatus(item.lifecycle_status),
+    lastSyncedSha: item.last_synced_sha,
+    lastPushedSha: item.last_pushed_sha,
+    cleanupPolicy: parseCleanupPolicy(item.cleanup_policy_json),
+    directPushAllowed: item.direct_push_allowed === 1,
+    adopted: item.adopted === 1,
+    createdBy: item.created_by,
+    createdAt: item.created_at,
+    updatedAt: item.updated_at,
+  };
+}
+
+export function readLockRow(row: unknown): WorktreeLockRecord {
+  const item = parseDatabaseRow(lockRowSchema, row, 'worktree lock');
+  return {
+    id: item.id,
+    scope: item.scope === 'pr' ? 'pr' : 'worktree',
+    scopeKey: item.scope_key,
+    worktreeId: item.worktree_id,
+    repoId: item.repo_id,
+    prNumber: item.pr_number,
+    owner: item.owner,
+    workflowRunId: item.workflow_run_id,
+    expiresAt: item.expires_at,
+    releasedAt: item.released_at,
+    staleRecoveredAt: item.stale_recovered_at,
+    createdAt: item.created_at,
+    updatedAt: item.updated_at,
+  };
+}
+
+function readCleanupAttemptRow(row: unknown) {
+  const item = parseDatabaseRow(
+    cleanupAttemptRowSchema,
+    row,
+    'worktree cleanup attempt',
+  );
+  return {
+    id: item.id,
+    worktreeId: item.worktree_id,
+    repoId: item.repo_id,
+    action: item.action,
+    outcome: item.outcome,
+    reason: item.reason,
+    error: item.error,
+    deleted: item.deleted === 1,
+    attemptedAt: item.attempted_at,
+  };
+}
+
+function parseCleanupPolicy(value: unknown): WorktreeCleanupPolicy {
+  if (typeof value !== 'string') return cleanupPolicy();
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    const policy = v.safeParse(worktreeCleanupPolicySchema, parsed);
+    if (!policy.success) {
+      throw new Error(v.summarize(policy.issues));
+    }
+    return cleanupPolicy(policy.output);
+  } catch (error) {
+    throw new WorktreeError(
+      'CORRUPT_WORKTREE_ROW',
+      `Invalid worktree cleanup policy JSON: ${errorMessage(error)}`,
+    );
+  }
+}
+
+function normalizeStatus(value: unknown): WorktreeLifecycleStatus {
+  const parsed = v.safeParse(lifecycleStatusSchema, value);
+  return parsed.success ? parsed.output : 'failed';
+}
+
+function parseDatabaseRow<T>(
+  schema: v.GenericSchema<unknown, T>,
+  row: unknown,
+  label: string,
+) {
+  const parsed = v.safeParse(schema, row);
+  if (parsed.success) return parsed.output;
+  throw new WorktreeError(
+    'CORRUPT_WORKTREE_ROW',
+    `Invalid ${label} row: ${v.summarize(parsed.issues)}`,
+  );
+}

package/src/repo-edit/actions.ts

@@ -0,0 +1,129 @@
+import { defineAction, defineTool } from '@flue/runtime';
+import {
+  readRepoCheckoutStatus,
+  readRepoDiff,
+  readRepoFile,
+  replaceRepoFile,
+  searchRepoFiles,
+  writeRepoFile,
+} from './service';
+import { patchRepoFiles } from './patch-service';
+import {
+  repoDiffInputSchema,
+  repoEditOutputSchema,
+  repoPatchInputSchema,
+  repoReadInputSchema,
+  repoReplaceInputSchema,
+  repoSearchInputSchema,
+  repoStatusInputSchema,
+  repoWriteInputSchema,
+} from './schemas';
+
+export const repoFileReadAction = defineAction({
+  name: 'neondeck_repo_file_read',
+  description:
+    'Read one text file from a configured Neondeck repo using a repo-relative path. Never prompts inside declared workspaces.',
+  input: repoReadInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return readRepoFile(input);
+  },
+});
+
+export const repoFileSearchAction = defineAction({
+  name: 'neondeck_repo_file_search',
+  description:
+    'Search text files in a configured Neondeck repo using rg-style deterministic search.',
+  input: repoSearchInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return searchRepoFiles(input);
+  },
+});
+
+export const repoFileWriteAction = defineAction({
+  name: 'neondeck_repo_file_write',
+  description:
+    'Write a complete text file inside a configured Neondeck repo. Use for generated files or deliberate full rewrites.',
+  input: repoWriteInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return writeRepoFile(input);
+  },
+});
+
+export const repoFileReplaceAction = defineAction({
+  name: 'neondeck_repo_file_replace',
+  description:
+    'Replace an exact or safe fuzzy old string with a new string inside one configured repo file.',
+  input: repoReplaceInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return replaceRepoFile(input);
+  },
+});
+
+export const repoFilePatchAction = defineAction({
+  name: 'neondeck_repo_file_patch',
+  description:
+    'Apply a V4A/Codex-style multi-file patch inside a configured Neondeck repo. Validates all files before mutating.',
+  input: repoPatchInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return patchRepoFiles(input);
+  },
+});
+
+export const repoDiffAction = defineAction({
+  name: 'neondeck_repo_diff',
+  description:
+    'Return git-backed diff summary and optional patch content for a configured Neondeck repo.',
+  input: repoDiffInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return readRepoDiff(input);
+  },
+});
+
+export const repoStatusAction = defineAction({
+  name: 'neondeck_repo_checkout_status',
+  description:
+    'Return branch, upstream, ahead/behind, and changed file status for a configured Neondeck repo.',
+  input: repoStatusInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return readRepoCheckoutStatus(input);
+  },
+});
+
+export const repoDiffTool = defineTool({
+  name: 'neondeck_repo_diff_lookup',
+  description: 'Read git diff summary for a configured Neondeck repo.',
+  input: repoDiffInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return readRepoDiff(input);
+  },
+});
+
+export const repoStatusTool = defineTool({
+  name: 'neondeck_repo_checkout_status_lookup',
+  description: 'Read checkout status for a configured Neondeck repo.',
+  input: repoStatusInputSchema,
+  output: repoEditOutputSchema,
+  async run({ input }) {
+    return readRepoCheckoutStatus(input);
+  },
+});
+
+export const neondeckRepoEditActions = [
+  repoFileReadAction,
+  repoFileSearchAction,
+  repoFileWriteAction,
+  repoFileReplaceAction,
+  repoFilePatchAction,
+  repoDiffAction,
+  repoStatusAction,
+];
+
+export const neondeckRepoEditTools = [repoDiffTool, repoStatusTool];

package/src/repo-edit/audit.ts

@@ -0,0 +1,180 @@
+import { randomUUID } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
+import {
+  ensureRuntimeHome,
+  type RuntimePaths,
+  runtimePaths,
+} from '../runtime-home';
+import type { DiffSummary, RepoEditStatus } from './schemas';
+
+export type RepoEditEventInput = {
+  repoId: string;
+  worktreeId?: string | null;
+  sessionId?: string | null;
+  workflowRunId?: string | null;
+  actorType?: 'agent' | 'user' | 'system';
+  actorId?: string | null;
+  action: string;
+  status: RepoEditStatus;
+  reason?: string | null;
+  paths: string[];
+  inputHash?: string | null;
+  diffSummary?: DiffSummary | null;
+  diffPatch?: string | null;
+  error?: unknown;
+};
+
+export type RepoEditEventRecord = RepoEditEventInput & {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export async function recordRepoEditEvent(
+  input: RepoEditEventInput,
+  paths: RuntimePaths = runtimePaths(),
+) {
+  await ensureRuntimeHome(paths);
+  const now = new Date().toISOString();
+  const record: RepoEditEventRecord = {
+    ...input,
+    id: randomUUID(),
+    actorType: input.actorType ?? 'agent',
+    actorId: input.actorId ?? null,
+    sessionId: input.sessionId ?? null,
+    workflowRunId: input.workflowRunId ?? null,
+    reason: input.reason ?? null,
+    inputHash: input.inputHash ?? null,
+    diffSummary: input.diffSummary ?? null,
+    diffPatch: cap(input.diffPatch ?? null),
+    createdAt: now,
+    updatedAt: now,
+  };
+  const database = new DatabaseSync(paths.neondeckDatabase);
+
+  try {
+    database
+      .prepare(
+        `
+        INSERT INTO repo_edit_events (
+          id,
+          repo_id,
+          worktree_id,
+          session_id,
+          workflow_run_id,
+          actor_type,
+          actor_id,
+          action,
+          status,
+          reason,
+          paths_json,
+          input_hash,
+          diff_summary_json,
+          diff_patch,
+          error_json,
+          created_at,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
+      `,
+      )
+      .run(
+        record.id,
+        record.repoId,
+        record.worktreeId ?? null,
+        record.sessionId ?? null,
+        record.workflowRunId ?? null,
+        record.actorType ?? 'agent',
+        record.actorId ?? null,
+        record.action,
+        record.status,
+        record.reason ?? null,
+        JSON.stringify(record.paths),
+        record.inputHash ?? null,
+        record.diffSummary ? JSON.stringify(record.diffSummary) : null,
+        record.diffPatch ?? null,
+        record.error === undefined ? null : JSON.stringify(record.error),
+        record.createdAt,
+        record.updatedAt,
+      );
+  } finally {
+    database.close();
+  }
+
+  return record;
+}
+
+export async function listRepoEditEvents(paths: RuntimePaths = runtimePaths()) {
+  await ensureRuntimeHome(paths);
+  const database = new DatabaseSync(paths.neondeckDatabase, { readOnly: true });
+
+  try {
+    return {
+      ok: true,
+      action: 'repo_edit_events_list',
+      changed: false,
+      message: 'Read recent repo edit events.',
+      events: database
+        .prepare(
+          `
+          SELECT *
+          FROM repo_edit_events
+          ORDER BY updated_at DESC, created_at DESC
+          LIMIT 100;
+        `,
+        )
+        .all()
+        .map(readRepoEditEventRow),
+      fetchedAt: new Date().toISOString(),
+    };
+  } finally {
+    database.close();
+  }
+}
+
+function readRepoEditEventRow(row: unknown) {
+  const item = row as Record<string, unknown>;
+  return {
+    id: String(item.id),
+    repoId: String(item.repo_id),
+    worktreeId: nullableString(item.worktree_id),
+    sessionId: nullableString(item.session_id),
+    workflowRunId: nullableString(item.workflow_run_id),
+    actorType: String(item.actor_type),
+    actorId: nullableString(item.actor_id),
+    action: String(item.action),
+    status: String(item.status),
+    reason: nullableString(item.reason),
+    paths: parseJsonArray(item.paths_json),
+    inputHash: nullableString(item.input_hash),
+    diffSummary: parseJson(item.diff_summary_json),
+    diffPatch: nullableString(item.diff_patch),
+    error: parseJson(item.error_json),
+    createdAt: String(item.created_at),
+    updatedAt: String(item.updated_at),
+  };
+}
+
+function nullableString(value: unknown) {
+  return typeof value === 'string' ? value : null;
+}
+
+function parseJson(value: unknown) {
+  if (typeof value !== 'string' || !value) return null;
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+function parseJsonArray(value: unknown) {
+  const parsed = parseJson(value);
+  return Array.isArray(parsed) ? parsed : [];
+}
+
+function cap(value: string | null) {
+  if (value === null) return null;
+  const max = 256 * 1024;
+  return value.length > max ? value.slice(0, max) : value;
+}