codetrap 0.1.6 → 0.1.8

package/src/lib/session-operations.ts

@@ -1,14 +1,31 @@
 import type { CandidateTrap } from "../domain/session";
-import { buildTrapInput } from "../domain/trap";
+import type { Scope } from "./constants";
 import type { TrapOperations } from "./trap-operations";
+import {
+  capturedCandidateDraft,
+  capturedTrapInput,
+  candidateWithTrapEdits,
+  captureGoal,
+} from "./session-capture";
+import { candidateAcceptedScope } from "./session-candidate-scope";
 import { findCandidateConflicts, type CandidateConflict } from "./session-conflicts";
+import {
+  projectCandidateReviewSummary,
+  sessionCandidateReviewSummary,
+  sessionIndexEntryWithReview,
+  type ProjectCandidateReviewSummary,
+} from "./session-review";
 import type {
   AcceptCandidateResult,
   AddSessionNoteArgs,
   CloseSessionResult,
+  DeleteSessionResult,
+  PruneSessionsResult,
+  RemoveSessionCandidatesResult,
   SessionStore,
   StartSessionArgs,
 } from "./session-store";
+import { uniqueStrings } from "./string-list";
 
 export type SessionAcceptRequest = {
   candidateId: string;
@@ -30,6 +47,21 @@ export type SessionRejectRequest = {
   reason?: string | null;
 };
 
+export type SessionPruneRequest = {
+  olderThanDays: number;
+  apply: boolean;
+  now?: Date;
+};
+
+export type SessionCaptureRequest = {
+  trap: Record<string, unknown>;
+  goal?: string;
+  kind?: string;
+  relatedFiles?: string[];
+  sourceRef?: string;
+  evidenceNote?: string;
+};
+
 export type SessionConflictResult = {
   success: false;
   session_id: string;
@@ -43,6 +75,18 @@ export type SessionAcceptSuccess = AcceptCandidateResult & {
 
 export type SessionAcceptResult = SessionAcceptSuccess | SessionConflictResult;
 
+export type SessionCaptureResult = {
+  success: true;
+  session: ReturnType<SessionStore["getSession"]>;
+  candidate: CandidateTrap;
+  candidate_count: number;
+  candidates_path: string;
+  created_session: boolean;
+  closed_session: boolean;
+  duplicate: boolean;
+  recap_path: string | null;
+};
+
 export class SessionOperations {
   constructor(
     private readonly sessions: SessionStore,
@@ -58,11 +102,23 @@ export class SessionOperations {
   }
 
   status() {
-    return this.sessions.status();
+    return {
+      ...this.sessions.status(),
+      candidate_review: this.candidateReviewSummary(),
+    };
   }
 
   listSessions(args: { status?: string; limit?: number } = {}) {
-    return this.sessions.listSessions(args);
+    return this.sessions.listSessions(args).map((session) =>
+      sessionIndexEntryWithReview(session, this.sessions.candidateDocument(session.id).candidates)
+    );
+  }
+
+  candidateReviewSummary(): ProjectCandidateReviewSummary {
+    const sessions = this.sessions.listSessions({ status: "all" }).map((session) =>
+      sessionCandidateReviewSummary(session, this.sessions.candidateDocument(session.id).candidates)
+    );
+    return projectCandidateReviewSummary(sessions);
   }
 
   showSession(id: string) {
@@ -77,6 +133,39 @@ export class SessionOperations {
     return this.sessions.closeSession(id, proposeTraps);
   }
 
+  captureCandidate(request: SessionCaptureRequest): SessionCaptureResult {
+    const trap = capturedTrapInput(request.trap);
+    const active = this.sessions.status().session;
+    const createdSession = active === null;
+    const session = active ?? this.sessions.startSession({
+      goal: captureGoal(request.goal, trap.title),
+      module: trap.module,
+      owner: trap.owner,
+    });
+    const captured = this.sessions.addCandidate({
+      sessionId: session.id,
+      draft: capturedCandidateDraft(session, {
+        trap,
+        kind: request.kind,
+        relatedFiles: request.relatedFiles,
+        sourceRef: request.sourceRef,
+        evidenceNote: request.evidenceNote,
+      }),
+    });
+    const closed = createdSession ? this.sessions.closeSession(session.id, false) : null;
+    return {
+      success: true,
+      session: closed?.session ?? captured.session,
+      candidate: captured.candidate,
+      candidate_count: this.sessions.candidateDocument(session.id).candidates.length,
+      candidates_path: captured.candidates_path,
+      created_session: createdSession,
+      closed_session: closed !== null,
+      duplicate: captured.duplicate,
+      recap_path: closed?.recap_path ?? null,
+    };
+  }
+
   candidateDocument(id?: string) {
     return this.sessions.candidateDocument(id);
   }
@@ -155,60 +244,31 @@ export class SessionOperations {
       reason: request.reason,
     });
   }
-}
-
-function candidateWithTrapEdits(candidate: CandidateTrap, edit: Record<string, unknown> | undefined): CandidateTrap {
-  return {
-    ...candidate,
-    trap: normalizeCandidateTrap({
-      ...candidate.trap,
-      ...trapEdits(edit),
-    }) as CandidateTrap["trap"],
-  };
-}
-
-function normalizeCandidateTrap(args: Record<string, unknown>) {
-  return buildTrapInput({
-    ...args,
-    tags: stringArray(args.tags),
-    path_globs: stringArray(args.path_globs),
-    module: optionalText(args.module),
-    owner: optionalText(args.owner),
-    before_code: optionalText(args.before_code),
-    after_code: optionalText(args.after_code),
-  });
-}
 
-function stringArray(value: unknown): string[] | undefined {
-  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
-  if (typeof value === "string") {
-    const values = value.split(",").map((item) => item.trim()).filter(Boolean);
-    return values.length > 0 ? values : undefined;
+  deleteSession(sessionId: string): DeleteSessionResult {
+    return this.sessions.deleteSession(sessionId);
   }
-  return undefined;
-}
-
-function optionalText(value: unknown): string | null | undefined {
-  if (value === undefined) return undefined;
-  if (value === null) return null;
-  const text = String(value).trim();
-  return text ? text : null;
-}
 
-function trapEdits(edit: Record<string, unknown> | undefined): Record<string, unknown> {
-  if (!edit) return {};
-  const nested = edit.trap;
-  return isRecord(nested) ? nested : edit;
-}
+  pruneSessions(request: SessionPruneRequest): PruneSessionsResult {
+    const now = request.now ?? new Date();
+    const cutoff = new Date(now.getTime() - request.olderThanDays * 24 * 60 * 60 * 1000);
+    return this.sessions.pruneSessions({ cutoff, dryRun: !request.apply });
+  }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  cleanupDeletedTrapCandidates(sessionId?: string): RemoveSessionCandidatesResult {
+    const document = this.sessions.candidateDocument(sessionId);
+    const missingCandidateIds = document.candidates
+      .filter((candidate) => candidate.status === "accepted")
+      .filter((candidate) => {
+        const trapId = candidate.accepted_trap_id;
+        if (trapId === undefined) return true;
+        return !this.traps.getTrapDetails(trapId, candidateAcceptedScope(candidate));
+      })
+      .map((candidate) => candidate.id);
+    return this.sessions.removeCandidates(sessionId, missingCandidateIds);
+  }
 }
 
 function candidateRelatedFiles(candidate: CandidateTrap): string[] {
   return uniqueStrings(candidate.evidence.flatMap((evidence) => evidence.related_files ?? []));
 }
-
-function uniqueStrings(values: string[]): string[] {
-  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
-}

package/src/lib/session-review.ts

@@ -0,0 +1,327 @@
+import type { CandidateTrap, SessionIndexEntry, SessionMetadata } from "../domain/session";
+import type { Scope } from "./constants";
+import { candidateAcceptedScope } from "./session-candidate-scope";
+import {
+  CANDIDATES_FILE,
+  NOTES_FILE,
+  RECAP_FILE,
+  sessionRelativeDir,
+  sessionRelativeFile,
+} from "./session-codec";
+import type { CandidateConflict } from "./session-conflicts";
+import type { TrapOperations } from "./trap-operations";
+
+export type SessionPayload = SessionMetadata & {
+  session_dir: string;
+  notes_path: string;
+  recap_path: string;
+  candidate_traps_path: string;
+};
+
+export type SessionConflictPayload = {
+  success: false;
+  error: string;
+  session_id: string;
+  candidate_id: string;
+  possible_conflicts: CandidateConflict[];
+};
+
+export type SessionCliConflictPayload = SessionConflictPayload & {
+  next_actions: string[];
+};
+
+export type SessionAcceptPayload = {
+  success: true;
+  session_id: string;
+  candidate_id: string;
+  status: CandidateTrap["status"];
+  trap_id: number;
+  scope: string;
+  evidence_id: number | null;
+  superseded_id: number | null;
+};
+
+export type SessionRejectPayload = {
+  success: true;
+  session_id: string;
+  candidate_id: string;
+  status: CandidateTrap["status"];
+  reason: string | null;
+};
+
+export type SessionCleanupPayload = {
+  success: true;
+  session_id: string;
+  removed_count: number;
+  removed_candidate_ids: string[];
+};
+
+export type SessionCandidateReview =
+  | { status: "pending"; label: string }
+  | {
+      status: "accepted";
+      label: string;
+      trap_id: number;
+      scope: string;
+      trap_present: true;
+      trap_status: string;
+      trap_title: string;
+    }
+  | {
+      status: "accepted_missing";
+      label: string;
+      trap_id?: number;
+      scope?: string;
+      trap_present: false;
+    }
+  | {
+      status: "rejected";
+      label: string;
+      rejected_at?: string;
+      rejection_reason?: string;
+    };
+
+export type ReviewedSessionCandidate = CandidateTrap & { review: SessionCandidateReview };
+
+export type CandidateReviewCounts = {
+  candidate_count: number;
+  pending_count: number;
+  reviewed_count: number;
+  accepted_count: number;
+  rejected_count: number;
+  high_quality_pending_count: number;
+  needs_edit_count: number;
+};
+
+export type SessionCandidateReviewSummary = CandidateReviewCounts & {
+  session_id: string;
+  goal: string;
+  status: SessionIndexEntry["status"];
+};
+
+export type ProjectCandidateReviewSummary = CandidateReviewCounts & {
+  session_count: number;
+  pending_session_count: number;
+  next_session_id: string | null;
+};
+
+export type SessionIndexEntryWithReview = SessionIndexEntry & CandidateReviewCounts & {
+  candidate_review: SessionCandidateReviewSummary;
+};
+
+export function sessionPayload(session: SessionMetadata): SessionPayload {
+  return {
+    ...session,
+    session_dir: sessionRelativeDir(session.id),
+    notes_path: sessionRelativeFile(session.id, NOTES_FILE),
+    recap_path: sessionRelativeFile(session.id, RECAP_FILE),
+    candidate_traps_path: sessionRelativeFile(session.id, CANDIDATES_FILE),
+  };
+}
+
+export function sessionConflictPayload(result: {
+  session_id: string;
+  candidate_id: string;
+  possible_conflicts: CandidateConflict[];
+}): SessionConflictPayload {
+  return {
+    success: false,
+    error: "Possible active trap conflict found.",
+    session_id: result.session_id,
+    candidate_id: result.candidate_id,
+    possible_conflicts: result.possible_conflicts,
+  };
+}
+
+export function sessionCliConflictPayload(payload: SessionConflictPayload): SessionCliConflictPayload {
+  return {
+    ...payload,
+    next_actions: [
+      `codetrap session accept ${payload.candidate_id} --session ${payload.session_id} --accept-anyway`,
+      `codetrap session accept ${payload.candidate_id} --session ${payload.session_id} --supersedes <trap-id>`,
+      `codetrap session reject ${payload.candidate_id} --session ${payload.session_id} --reason <reason>`,
+    ],
+  };
+}
+
+export function sessionConflictText(payload: SessionConflictPayload): string {
+  return [
+    "Possible active trap conflict found:",
+    ...payload.possible_conflicts.map((conflict) => [
+      `#${conflict.trap_id} ${conflict.title}`,
+      `  reason: ${conflict.reason}`,
+      `  fix: ${conflict.fix}`,
+    ].join("\n")),
+    "",
+    "Use --accept-anyway to save as a new trap, or --supersedes <trap-id> to preserve lifecycle history.",
+  ].join("\n");
+}
+
+export function sessionAcceptPayload(accepted: {
+  session: SessionMetadata;
+  candidate: CandidateTrap;
+  trap_id: number;
+  scope: string;
+  evidence_id: number | null;
+  superseded_id: number | null;
+}): SessionAcceptPayload {
+  return {
+    success: true,
+    session_id: accepted.session.id,
+    candidate_id: accepted.candidate.id,
+    status: accepted.candidate.status,
+    trap_id: accepted.trap_id,
+    scope: accepted.scope,
+    evidence_id: accepted.evidence_id,
+    superseded_id: accepted.superseded_id,
+  };
+}
+
+export function sessionRejectPayload(rejected: {
+  session: SessionMetadata;
+  candidate: CandidateTrap;
+}): SessionRejectPayload {
+  return {
+    success: true,
+    session_id: rejected.session.id,
+    candidate_id: rejected.candidate.id,
+    status: rejected.candidate.status,
+    reason: rejected.candidate.rejection_reason ?? null,
+  };
+}
+
+export function sessionCleanupPayload(result: {
+  session: SessionMetadata;
+  removed_count: number;
+  removed_candidate_ids: string[];
+}): SessionCleanupPayload {
+  return {
+    success: true,
+    session_id: result.session.id,
+    removed_count: result.removed_count,
+    removed_candidate_ids: result.removed_candidate_ids,
+  };
+}
+
+export function reviewedSessionCandidates(
+  candidates: CandidateTrap[],
+  traps: TrapOperations
+): ReviewedSessionCandidate[] {
+  return candidates.map((candidate) => ({
+    ...candidate,
+    review: sessionCandidateReview(candidate, traps),
+  }));
+}
+
+export function candidateReviewCounts(candidates: CandidateTrap[]): CandidateReviewCounts {
+  const pending = candidates.filter((candidate) => candidate.status === "proposed");
+  const accepted = candidates.filter((candidate) => candidate.status === "accepted");
+  const rejected = candidates.filter((candidate) => candidate.status === "rejected");
+  return {
+    candidate_count: candidates.length,
+    pending_count: pending.length,
+    reviewed_count: accepted.length + rejected.length,
+    accepted_count: accepted.length,
+    rejected_count: rejected.length,
+    high_quality_pending_count: pending.filter((candidate) =>
+      candidate.quality_score >= 0.8 && candidate.quality.suggested_action === "accept"
+    ).length,
+    needs_edit_count: pending.filter((candidate) => candidate.quality.suggested_action === "edit").length,
+  };
+}
+
+export function sessionCandidateReviewSummary(
+  session: Pick<SessionIndexEntry, "id" | "goal" | "status">,
+  candidates: CandidateTrap[]
+): SessionCandidateReviewSummary {
+  return {
+    session_id: session.id,
+    goal: session.goal,
+    status: session.status,
+    ...candidateReviewCounts(candidates),
+  };
+}
+
+export function sessionIndexEntryWithReview(
+  session: SessionIndexEntry,
+  candidates: CandidateTrap[]
+): SessionIndexEntryWithReview {
+  const review = sessionCandidateReviewSummary(session, candidates);
+  return {
+    ...session,
+    ...review,
+    candidate_review: review,
+  };
+}
+
+export function projectCandidateReviewSummary(
+  sessions: SessionCandidateReviewSummary[]
+): ProjectCandidateReviewSummary {
+  const empty = candidateReviewCounts([]);
+  const totals = sessions.reduce<CandidateReviewCounts>((acc, session) => ({
+    candidate_count: acc.candidate_count + session.candidate_count,
+    pending_count: acc.pending_count + session.pending_count,
+    reviewed_count: acc.reviewed_count + session.reviewed_count,
+    accepted_count: acc.accepted_count + session.accepted_count,
+    rejected_count: acc.rejected_count + session.rejected_count,
+    high_quality_pending_count: acc.high_quality_pending_count + session.high_quality_pending_count,
+    needs_edit_count: acc.needs_edit_count + session.needs_edit_count,
+  }), empty);
+  const nextPending = sessions.find((session) => session.pending_count > 0);
+  return {
+    ...totals,
+    session_count: sessions.length,
+    pending_session_count: sessions.filter((session) => session.pending_count > 0).length,
+    next_session_id: nextPending?.session_id ?? null,
+  };
+}
+
+export function sessionCandidateReview(
+  candidate: CandidateTrap,
+  traps: TrapOperations
+): SessionCandidateReview {
+  if (candidate.status === "proposed") {
+    return { status: "pending", label: "pending review" };
+  }
+
+  if (candidate.status === "rejected") {
+    return {
+      status: "rejected",
+      label: "rejected",
+      rejected_at: candidate.rejected_at,
+      rejection_reason: candidate.rejection_reason,
+    };
+  }
+
+  const trapId = candidate.accepted_trap_id;
+  const scope = candidateAcceptedScope(candidate);
+  if (trapId === undefined) {
+    return {
+      status: "accepted_missing",
+      label: "accepted -> trap link missing",
+      scope,
+      trap_present: false,
+    };
+  }
+
+  const details = traps.getTrapDetails(trapId, scope);
+  if (!details) {
+    return {
+      status: "accepted_missing",
+      label: `accepted -> trap #${trapId} deleted`,
+      trap_id: trapId,
+      scope,
+      trap_present: false,
+    };
+  }
+
+  return {
+    status: "accepted",
+    label: `accepted -> trap #${trapId}`,
+    trap_id: trapId,
+    scope: details.scope,
+    trap_present: true,
+    trap_status: details.trap.status,
+    trap_title: details.trap.title,
+  };
+}