neondeck 1.0.0-beta.4

package/src/modules/prepared-diffs/actions.ts

@@ -0,0 +1,132 @@
+import { defineAction, defineTool } from '@flue/runtime';
+import {
+  abandonPreparedDiff,
+  listPreparedDiffs,
+  openPreparedDiffWorktree,
+  readPreparedDiffChangedFiles,
+  readPreparedDiffFileDiff,
+  readPreparedDiffSummary,
+  requestPreparedDiffRevision,
+  runPreparedDiffVerification,
+} from './service';
+import {
+  abandonInputSchema,
+  fileDiffInputSchema,
+  idInputSchema,
+  listInputSchema,
+  outputSchema,
+  requestRevisionInputSchema,
+  verificationInputSchema,
+} from './schemas';
+
+export const preparedDiffsLookupTool = defineTool({
+  name: 'neondeck_prepared_diffs_lookup',
+  description:
+    'List prepared-diff records and pending push/revision/abandon approvals. File-level diffs remain sourced from the managed worktree.',
+  input: listInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return listPreparedDiffs(input);
+  },
+});
+
+export const preparedDiffListAction = defineAction({
+  name: 'neondeck_prepared_diff_list',
+  description:
+    'List prepared diffs from Neondeck app state. The source worktree is the file-level source of truth.',
+  input: listInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return listPreparedDiffs(input);
+  },
+});
+
+export const preparedDiffSummaryAction = defineAction({
+  name: 'neondeck_prepared_diff_summary',
+  description:
+    'Read one prepared-diff record and recompute its diff summary from the managed source worktree.',
+  input: idInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readPreparedDiffSummary(input);
+  },
+});
+
+export const preparedDiffChangedFilesAction = defineAction({
+  name: 'neondeck_prepared_diff_changed_files',
+  description:
+    'Read changed files for one prepared diff by running backend git diff against its source worktree.',
+  input: idInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readPreparedDiffChangedFiles(input);
+  },
+});
+
+export const preparedDiffFileDiffAction = defineAction({
+  name: 'neondeck_prepared_diff_file_diff',
+  description:
+    'Read one file patch for a prepared diff by running backend git diff against its source worktree.',
+  input: fileDiffInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return readPreparedDiffFileDiff(input);
+  },
+});
+
+export const preparedDiffRequestRevisionAction = defineAction({
+  name: 'neondeck_prepared_diff_request_revision',
+  description:
+    'Request a revision for a prepared diff and keep the source worktree available for follow-up work.',
+  input: requestRevisionInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return requestPreparedDiffRevision(input);
+  },
+});
+
+export const preparedDiffAbandonAction = defineAction({
+  name: 'neondeck_prepared_diff_abandon',
+  description:
+    'Abandon a prepared-diff record without deleting its source worktree.',
+  input: abandonInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return abandonPreparedDiff(input);
+  },
+});
+
+export const preparedDiffOpenWorktreeAction = defineAction({
+  name: 'neondeck_prepared_diff_open_worktree',
+  description:
+    'Return the managed source worktree path for a prepared diff so a web or TUI client can open it.',
+  input: idInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return openPreparedDiffWorktree(input);
+  },
+});
+
+export const preparedDiffRunVerificationAction = defineAction({
+  name: 'neondeck_prepared_diff_run_verification',
+  description:
+    'Record a verification request for a prepared diff. The later verify_pr_worktree workflow owns actual command execution.',
+  input: verificationInputSchema,
+  output: outputSchema,
+  async run({ input }) {
+    return runPreparedDiffVerification(input);
+  },
+});
+
+export const neondeckPreparedDiffActions = [
+  preparedDiffListAction,
+  preparedDiffSummaryAction,
+  preparedDiffChangedFilesAction,
+  preparedDiffFileDiffAction,
+  preparedDiffRequestRevisionAction,
+  preparedDiffAbandonAction,
+  preparedDiffOpenWorktreeAction,
+  preparedDiffRunVerificationAction,
+];
+
+export const neondeckPreparedDiffTools = [preparedDiffsLookupTool];

package/src/modules/prepared-diffs/index.ts

@@ -0,0 +1,53 @@
+export type {
+  PreparedDiffActionResult,
+  PreparedDiffApprovalRecord,
+  PreparedDiffApprovalStatus,
+  PreparedDiffRecord,
+  PreparedDiffStatus,
+  PreparedDiffVerificationStatus,
+  WorktreeRecordLike,
+} from './schemas';
+export {
+  preparedDiffsLookupTool,
+  preparedDiffListAction,
+  preparedDiffSummaryAction,
+  preparedDiffChangedFilesAction,
+  preparedDiffFileDiffAction,
+  preparedDiffRequestRevisionAction,
+  preparedDiffAbandonAction,
+  preparedDiffOpenWorktreeAction,
+  preparedDiffRunVerificationAction,
+  neondeckPreparedDiffActions,
+  neondeckPreparedDiffTools,
+} from './actions';
+export {
+  ensurePreparedDiffForWorktree,
+  readPreparedDiff,
+  readPreparedDiffByWorktree,
+  recordPreparedDiffVerification,
+  markPreparedDiffPushBlocked,
+  markPreparedDiffPushed,
+  listPreparedDiffs,
+  readPreparedDiffSummary,
+  readPreparedDiffChangedFiles,
+  readPreparedDiffFileDiff,
+  approvePreparedDiffPush,
+  requestPreparedDiffRevision,
+  abandonPreparedDiff,
+  openPreparedDiffWorktree,
+  runPreparedDiffVerification,
+} from './service';
+export {
+  readApprovalRecord as readPreparedDiffApprovalRecord,
+  readPreparedDiffRecord,
+  readPreparedDiffByWorktreeId,
+  listApprovalRecords,
+  assertTransition,
+  mergeSummary,
+  updatePreparedDiffState,
+} from './store';
+export {
+  abandonInputSchema,
+  approvePushInputSchema,
+  runRevisionInputSchema,
+} from './schemas';

package/src/modules/prepared-diffs/schemas.ts

@@ -0,0 +1,255 @@
+/* eslint-disable no-unused-vars */
+import { defineAction, defineTool, type JsonValue } from '@flue/runtime';
+import { asJsonValue } from '../../lib/action-result';
+import { randomUUID } from 'node:crypto';
+import * as v from 'valibot';
+import { addNotification } from '../app-state';
+import { buildPreparedDiffAuditSummary } from '../autonomous-audit';
+import { openDb } from '../../lib/sqlite';
+import { gitCurrentSha, gitDiff, type RepoDiffFile } from '../../repo-edit/git';
+import {
+  type RuntimePaths,
+  ensureRuntimeHome,
+  runtimePaths,
+} from '../../runtime-home';
+
+export type PreparedDiffStatus =
+  | 'prepared'
+  | 'verification-requested'
+  | 'revision-requested'
+  | 'revision-in-progress'
+  | 'push-approved'
+  | 'push-blocked'
+  | 'pushed'
+  | 'abandoned';
+
+export type PreparedDiffApprovalStatus =
+  'not-requested' | 'pending' | 'approved' | 'rejected';
+
+export type PreparedDiffVerificationStatus =
+  'not-run' | 'requested' | 'running' | 'passed' | 'failed';
+
+export type PreparedDiffRecord = {
+  id: string;
+  worktreeId: string;
+  repoId: string;
+  repoFullName: string;
+  prNumber: number | null;
+  title: string;
+  sourceWorktreePath: string;
+  baseRef: string;
+  headRef: string;
+  headSha: string | null;
+  status: PreparedDiffStatus;
+  pushApprovalStatus: PreparedDiffApprovalStatus;
+  verificationStatus: PreparedDiffVerificationStatus;
+  summary: JsonValue | null;
+  sourceOfTruth: 'worktree';
+  createdBy: string;
+  createdAt: string;
+  updatedAt: string;
+  abandonedAt: string | null;
+};
+
+export type PreparedDiffApprovalRecord = {
+  id: string;
+  preparedDiffId: string;
+  worktreeId: string;
+  approvalType: 'push' | 'revision' | 'abandon' | 'verification';
+  status: 'pending' | 'approved' | 'rejected' | 'superseded';
+  targetSha: string | null;
+  policyHash: string | null;
+  policyDecision: 'deny' | 'require-approval' | 'allow' | null;
+  reason: string | null;
+  approverSurface: string | null;
+  requestedAt: string;
+  resolvedAt: string | null;
+  updatedAt: string;
+};
+
+export type WorktreeRecordLike = {
+  id: string;
+  repoId: string;
+  repoFullName: string;
+  prNumber: number | null;
+  localPath: string;
+  baseRef: string;
+  headRef: string;
+  headSha: string | null;
+  lifecycleStatus: string;
+};
+
+export type PreparedDiffActionResult = {
+  ok: boolean;
+  action: string;
+  changed: boolean;
+  message: string;
+  preparedDiff?: PreparedDiffRecord;
+  preparedDiffs?: PreparedDiffRecord[];
+  approvals?: PreparedDiffApprovalRecord[];
+  files?: RepoDiffFile[];
+  file?: RepoDiffFile | null;
+  diff?: string;
+  diffSummary?: {
+    files: number;
+    additions: number;
+    deletions: number;
+    binaryFiles: number;
+  };
+  data?: JsonValue;
+  error?: { code: string; message: string };
+  requires?: string[];
+  errors?: string[];
+};
+
+export const nonEmptyStringSchema = v.pipe(v.string(), v.minLength(1));
+export const repoRelativePathSchema = v.pipe(
+  nonEmptyStringSchema,
+  v.check((value) => {
+    const trimmed = value.trim();
+    return (
+      trimmed === '.' ||
+      (!trimmed.startsWith('/') &&
+        !trimmed.startsWith('-') &&
+        !trimmed.split(/[\\/]/).includes('..'))
+    );
+  }, 'Expected a safe repo-relative path.'),
+);
+export const preparedDiffStatusSchema = v.picklist([
+  'prepared',
+  'verification-requested',
+  'revision-requested',
+  'revision-in-progress',
+  'push-approved',
+  'push-blocked',
+  'pushed',
+  'abandoned',
+]);
+export const preparedDiffApprovalStatusSchema = v.picklist([
+  'not-requested',
+  'pending',
+  'approved',
+  'rejected',
+]);
+export const preparedDiffVerificationStatusSchema = v.picklist([
+  'not-run',
+  'requested',
+  'running',
+  'passed',
+  'failed',
+]);
+export const preparedDiffRecordSchema = v.object({
+  id: v.string(),
+  worktreeId: v.string(),
+  repoId: v.string(),
+  repoFullName: v.string(),
+  prNumber: v.nullable(v.number()),
+  title: v.string(),
+  sourceWorktreePath: v.string(),
+  baseRef: v.string(),
+  headRef: v.string(),
+  headSha: v.nullable(v.string()),
+  status: preparedDiffStatusSchema,
+  pushApprovalStatus: preparedDiffApprovalStatusSchema,
+  verificationStatus: preparedDiffVerificationStatusSchema,
+  summary: v.nullable(v.unknown()),
+  sourceOfTruth: v.literal('worktree'),
+  createdBy: v.string(),
+  createdAt: v.string(),
+  updatedAt: v.string(),
+  abandonedAt: v.nullable(v.string()),
+});
+export const outputSchema = v.looseObject({
+  ok: v.boolean(),
+  action: v.string(),
+  changed: v.boolean(),
+  message: v.string(),
+});
+export const listInputSchema = v.object({
+  status: v.optional(preparedDiffStatusSchema),
+  includeTerminal: v.optional(v.boolean()),
+  repoId: v.optional(nonEmptyStringSchema),
+});
+export const idInputSchema = v.object({
+  preparedDiffId: nonEmptyStringSchema,
+});
+export const fileDiffInputSchema = v.object({
+  preparedDiffId: nonEmptyStringSchema,
+  path: repoRelativePathSchema,
+  maxPatchBytes: v.optional(
+    v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(256 * 1024)),
+  ),
+});
+export const approvePushInputSchema = v.object({
+  preparedDiffId: nonEmptyStringSchema,
+  reason: v.optional(v.string()),
+  approverSurface: v.optional(nonEmptyStringSchema),
+  confirm: v.optional(v.boolean()),
+});
+export const requestRevisionInputSchema = v.object({
+  preparedDiffId: nonEmptyStringSchema,
+  reason: v.optional(v.string()),
+  approverSurface: v.optional(nonEmptyStringSchema),
+});
+export const runRevisionInputSchema = v.object({
+  preparedDiffId: nonEmptyStringSchema,
+  reason: v.optional(v.string()),
+  approverSurface: v.optional(nonEmptyStringSchema),
+});
+export const abandonInputSchema = v.object({
+  preparedDiffId: nonEmptyStringSchema,
+  reason: v.optional(v.string()),
+  approverSurface: v.optional(nonEmptyStringSchema),
+  confirm: v.optional(v.boolean()),
+});
+export const verificationInputSchema = v.object({
+  preparedDiffId: nonEmptyStringSchema,
+  checkName: v.optional(nonEmptyStringSchema),
+  approverSurface: v.optional(nonEmptyStringSchema),
+});
+export const worktreeRowSchema = v.object({
+  id: v.string(),
+  repo_id: v.string(),
+  repo_full_name: v.string(),
+  pr_number: v.nullable(v.number()),
+  local_path: v.string(),
+  base_ref: v.string(),
+  head_ref: v.string(),
+  head_sha: v.nullable(v.string()),
+  lifecycle_status: v.string(),
+});
+export const preparedDiffRowSchema = v.object({
+  id: v.string(),
+  worktree_id: v.string(),
+  repo_id: v.string(),
+  repo_full_name: v.string(),
+  pr_number: v.nullable(v.number()),
+  title: v.string(),
+  source_worktree_path: v.string(),
+  base_ref: v.string(),
+  head_ref: v.string(),
+  head_sha: v.nullable(v.string()),
+  status: v.string(),
+  push_approval_status: v.string(),
+  verification_status: v.string(),
+  summary_json: v.nullable(v.string()),
+  created_by: v.string(),
+  created_at: v.string(),
+  updated_at: v.string(),
+  abandoned_at: v.nullable(v.string()),
+});
+export const approvalRowSchema = v.object({
+  id: v.string(),
+  prepared_diff_id: v.string(),
+  worktree_id: v.string(),
+  approval_type: v.string(),
+  status: v.string(),
+  target_sha: v.nullable(v.string()),
+  policy_hash: v.nullable(v.string()),
+  policy_decision: v.nullable(v.string()),
+  reason: v.nullable(v.string()),
+  approver_surface: v.nullable(v.string()),
+  requested_at: v.string(),
+  resolved_at: v.nullable(v.string()),
+  updated_at: v.string(),
+});