@autobe/agent 0.30.0-dev.20260315 → 0.30.0

package/src/utils/predicateStateMessage.ts

@@ -1,131 +1,131 @@
-import { AutoBePhase } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-
-import { AutoBeState } from "../context/AutoBeState";
-
-/**
- * Validates pipeline state before executing a phase, returning user-friendly
- * error message if prerequisites are missing or outdated.
- *
- * Enforces the waterfall dependency structure: each phase requires all previous
- * phases to be completed with matching step counters. When requirements change
- * (analyze step increments), downstream phases become invalid through step
- * mismatch, and this function generates clear messages guiding users to
- * regenerate affected phases.
- *
- * This is the gatekeeper preventing users from executing phases out of order or
- * with stale dependencies, ensuring generated artifacts always reflect current
- * requirements. Without this validation, users could generate API
- * implementations based on outdated database schemas, causing subtle bugs.
- *
- * @param state Current pipeline state
- * @param future Phase attempting to execute
- * @returns Error message if validation fails, null if valid to proceed
- */
-export const predicateStateMessage = (
-  state: AutoBeState,
-  future: AutoBePhase,
-): string | null => {
-  if (future === "analyze") return null;
-  if (future === "database") return predicateDatabase(state);
-
-  const futureIndex: number = STEP_ORDER.indexOf(future);
-  for (const key of STEP_ORDER.slice(0, futureIndex))
-    if (state[key] === null) return buildMissingStepsMessage(future, key);
-
-  const prevStepName: AutoBePhase = STEP_ORDER[futureIndex - 1];
-  if (state.analyze!.step !== state[prevStepName]!.step)
-    return buildOutdatedMessage(prevStepName, "analyze", state);
-  return null;
-};
-
-/** Generates error message listing steps needed to reach current phase. */
-const buildMissingStepsMessage = (
-  current: AutoBePhase,
-  missing: AutoBePhase,
-): string => {
-  const currentIndex: number = STEP_ORDER.indexOf(current);
-  const missingIndex: number = STEP_ORDER.indexOf(missing);
-  const remainingSteps: string = STEP_ORDER.slice(
-    missingIndex,
-    currentIndex + 1,
-  )
-    .map((step, index) => `${index + 1}. ${STEP_DESCRIPTIONS[step]}`)
-    .join("\n    ");
-
-  const currentAction = ACTION_NAMES[current];
-
-  return StringUtil.trim`
-    ${STEP_DESCRIPTIONS[missing]} not completed yet.
-
-    To ${currentAction}, complete these steps:
-    
-    ${remainingSteps}
-
-    Start with step ${missingIndex + 1}.
-  `;
-};
-
-/**
- * Generates error message indicating phase is outdated due to requirements
- * change.
- */
-const buildOutdatedMessage = (
-  outdatedStep: AutoBePhase,
-  currentStep: AutoBePhase,
-  state: AutoBeState,
-): string => {
-  const outdatedVersion = state[outdatedStep]?.step;
-  const currentVersion = state[currentStep]?.step;
-
-  return StringUtil.trim`
-    ${STEP_NAMES[outdatedStep]} is outdated (step ${outdatedVersion}).
-    
-    Requirements are now at step ${currentVersion}.
-    
-    Please update ${outdatedStep} to match current requirements.
-  `;
-};
-
-/** Special validation for Database phase requiring only analyze completion. */
-const predicateDatabase = (state: AutoBeState): string | null => {
-  if (state.analyze !== null) return null;
-  return StringUtil.trim`
-    Requirements analysis not started.
-    
-    Discuss your project with AI to generate requirements analysis.
-    Database design will follow after requirements are ready.
-  `;
-};
-
-const STEP_DESCRIPTIONS: Record<AutoBePhase, string> = {
-  analyze: "Requirements analysis",
-  database: "Database design",
-  interface: "API interface design",
-  test: "E2E test creation",
-  realize: "Implementation",
-};
-
-const STEP_NAMES: Record<AutoBePhase, string> = {
-  analyze: "Requirements analysis",
-  database: "Database schema",
-  interface: "API interface",
-  test: "Test functions",
-  realize: "Implementation",
-};
-
-const ACTION_NAMES: Record<AutoBePhase, string> = {
-  analyze: "analyze requirements",
-  database: "design database",
-  interface: "design API interface",
-  test: "create tests",
-  realize: "implement the program",
-};
-
-const STEP_ORDER: AutoBePhase[] = [
-  "analyze",
-  "database",
-  "interface",
-  "test",
-  "realize",
-];
+import { AutoBePhase } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+
+import { AutoBeState } from "../context/AutoBeState";
+
+/**
+ * Validates pipeline state before executing a phase, returning user-friendly
+ * error message if prerequisites are missing or outdated.
+ *
+ * Enforces the waterfall dependency structure: each phase requires all previous
+ * phases to be completed with matching step counters. When requirements change
+ * (analyze step increments), downstream phases become invalid through step
+ * mismatch, and this function generates clear messages guiding users to
+ * regenerate affected phases.
+ *
+ * This is the gatekeeper preventing users from executing phases out of order or
+ * with stale dependencies, ensuring generated artifacts always reflect current
+ * requirements. Without this validation, users could generate API
+ * implementations based on outdated database schemas, causing subtle bugs.
+ *
+ * @param state Current pipeline state
+ * @param future Phase attempting to execute
+ * @returns Error message if validation fails, null if valid to proceed
+ */
+export const predicateStateMessage = (
+  state: AutoBeState,
+  future: AutoBePhase,
+): string | null => {
+  if (future === "analyze") return null;
+  if (future === "database") return predicateDatabase(state);
+
+  const futureIndex: number = STEP_ORDER.indexOf(future);
+  for (const key of STEP_ORDER.slice(0, futureIndex))
+    if (state[key] === null) return buildMissingStepsMessage(future, key);
+
+  const prevStepName: AutoBePhase = STEP_ORDER[futureIndex - 1];
+  if (state.analyze!.step !== state[prevStepName]!.step)
+    return buildOutdatedMessage(prevStepName, "analyze", state);
+  return null;
+};
+
+/** Generates error message listing steps needed to reach current phase. */
+const buildMissingStepsMessage = (
+  current: AutoBePhase,
+  missing: AutoBePhase,
+): string => {
+  const currentIndex: number = STEP_ORDER.indexOf(current);
+  const missingIndex: number = STEP_ORDER.indexOf(missing);
+  const remainingSteps: string = STEP_ORDER.slice(
+    missingIndex,
+    currentIndex + 1,
+  )
+    .map((step, index) => `${index + 1}. ${STEP_DESCRIPTIONS[step]}`)
+    .join("\n    ");
+
+  const currentAction = ACTION_NAMES[current];
+
+  return StringUtil.trim`
+    ${STEP_DESCRIPTIONS[missing]} not completed yet.
+
+    To ${currentAction}, complete these steps:
+    
+    ${remainingSteps}
+
+    Start with step ${missingIndex + 1}.
+  `;
+};
+
+/**
+ * Generates error message indicating phase is outdated due to requirements
+ * change.
+ */
+const buildOutdatedMessage = (
+  outdatedStep: AutoBePhase,
+  currentStep: AutoBePhase,
+  state: AutoBeState,
+): string => {
+  const outdatedVersion = state[outdatedStep]?.step;
+  const currentVersion = state[currentStep]?.step;
+
+  return StringUtil.trim`
+    ${STEP_NAMES[outdatedStep]} is outdated (step ${outdatedVersion}).
+    
+    Requirements are now at step ${currentVersion}.
+    
+    Please update ${outdatedStep} to match current requirements.
+  `;
+};
+
+/** Special validation for Database phase requiring only analyze completion. */
+const predicateDatabase = (state: AutoBeState): string | null => {
+  if (state.analyze !== null) return null;
+  return StringUtil.trim`
+    Requirements analysis not started.
+    
+    Discuss your project with AI to generate requirements analysis.
+    Database design will follow after requirements are ready.
+  `;
+};
+
+const STEP_DESCRIPTIONS: Record<AutoBePhase, string> = {
+  analyze: "Requirements analysis",
+  database: "Database design",
+  interface: "API interface design",
+  test: "E2E test creation",
+  realize: "Implementation",
+};
+
+const STEP_NAMES: Record<AutoBePhase, string> = {
+  analyze: "Requirements analysis",
+  database: "Database schema",
+  interface: "API interface",
+  test: "Test functions",
+  realize: "Implementation",
+};
+
+const ACTION_NAMES: Record<AutoBePhase, string> = {
+  analyze: "analyze requirements",
+  database: "design database",
+  interface: "design API interface",
+  test: "create tests",
+  realize: "implement the program",
+};
+
+const STEP_ORDER: AutoBePhase[] = [
+  "analyze",
+  "database",
+  "interface",
+  "test",
+  "realize",
+];

package/src/utils/validateEmptyCode.ts

@@ -1,73 +1,73 @@
-import { StringUtil } from "@autobe/utils";
-import { IValidation } from "typia";
-
-/**
- * Validates that AI-generated code contains the expected function name.
- *
- * Detects two common AI failure modes: (1) returning empty code snippets
- * instead of actual implementations, and (2) hallucinating different function
- * names than requested. By checking function name presence early, this prevents
- * wasting compiler resources on obviously broken code and provides clearer
- * error messages to the correction orchestrator.
- *
- * Used extensively in Test and Realize phases where AI generates test functions
- * and API operation implementations. Without this validation, empty or misnamed
- * functions would pass to TypeScript compiler, generating confusing "not found"
- * errors instead of actionable "you forgot to write the function" feedback.
- *
- * @param props Function name to validate and code strings to check
- * @returns Array of validation errors (empty if valid)
- */
-export const validateEmptyCode = (props: {
-  path: string;
-  asynchronous: boolean;
-  name: string;
-  draft: string;
-  revise: {
-    final: string | null;
-  };
-}): IValidation.IError[] => {
-  const errors: IValidation.IError[] = [];
-  const declaration: string =
-    props.asynchronous === true
-      ? `export async function ${props.name}(`
-      : `export function ${props.name}(`;
-
-  if (props.draft.includes(declaration) === false)
-    errors.push({
-      path: `${props.path}.draft`,
-      expected: `string (including function declaration starting with '${props.name}')`,
-      value: props.draft,
-      description: description(declaration),
-    });
-  if (
-    props.revise.final !== null &&
-    props.revise.final.includes(declaration) === false
-  )
-    errors.push({
-      path: `${props.path}.revise.final`,
-      expected: `string (including function declaration starting with '${props.name}')`,
-      value: props.revise.final,
-      description: description(declaration),
-    });
-  return errors;
-};
-
-/** Generates detailed error description for missing function. */
-const description = (declaration: string): string => StringUtil.trim`
-  \`\`\`
-  ${declaration}
-  \`\`\`
-
-  The above function declaration does not exist in the provided code snippet.
-  You have to declare the function exactly starting with the above line.
-
-  The first reason of the non-existence is that the code snippet is empty,
-  and the second reason is that AI has written different function name
-  by mistake.
-
-  Please make sure that the code snippet includes the function "${declaration}".
-  
-  Note that, you never have to write empty code or different function name.
-  This is not a recommendation, but an instruction you must obey.
-`;
+import { StringUtil } from "@autobe/utils";
+import { IValidation } from "typia";
+
+/**
+ * Validates that AI-generated code contains the expected function name.
+ *
+ * Detects two common AI failure modes: (1) returning empty code snippets
+ * instead of actual implementations, and (2) hallucinating different function
+ * names than requested. By checking function name presence early, this prevents
+ * wasting compiler resources on obviously broken code and provides clearer
+ * error messages to the correction orchestrator.
+ *
+ * Used extensively in Test and Realize phases where AI generates test functions
+ * and API operation implementations. Without this validation, empty or misnamed
+ * functions would pass to TypeScript compiler, generating confusing "not found"
+ * errors instead of actionable "you forgot to write the function" feedback.
+ *
+ * @param props Function name to validate and code strings to check
+ * @returns Array of validation errors (empty if valid)
+ */
+export const validateEmptyCode = (props: {
+  path: string;
+  asynchronous: boolean;
+  name: string;
+  draft: string;
+  revise: {
+    final: string | null;
+  };
+}): IValidation.IError[] => {
+  const errors: IValidation.IError[] = [];
+  const declaration: string =
+    props.asynchronous === true
+      ? `export async function ${props.name}(`
+      : `export function ${props.name}(`;
+
+  if (props.draft.includes(declaration) === false)
+    errors.push({
+      path: `${props.path}.draft`,
+      expected: `string (including function declaration starting with '${props.name}')`,
+      value: props.draft,
+      description: description(declaration),
+    });
+  if (
+    props.revise.final !== null &&
+    props.revise.final.includes(declaration) === false
+  )
+    errors.push({
+      path: `${props.path}.revise.final`,
+      expected: `string (including function declaration starting with '${props.name}')`,
+      value: props.revise.final,
+      description: description(declaration),
+    });
+  return errors;
+};
+
+/** Generates detailed error description for missing function. */
+const description = (declaration: string): string => StringUtil.trim`
+  \`\`\`
+  ${declaration}
+  \`\`\`
+
+  The above function declaration does not exist in the provided code snippet.
+  You have to declare the function exactly starting with the above line.
+
+  The first reason of the non-existence is that the code snippet is empty,
+  and the second reason is that AI has written different function name
+  by mistake.
+
+  Please make sure that the code snippet includes the function "${declaration}".
+  
+  Note that, you never have to write empty code or different function name.
+  This is not a recommendation, but an instruction you must obey.
+`;