ferix-code 0.0.2 → 0.0.3-beta.1

package/dist/chunk-ENDDBBCW.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import {
+  init_esm_shims
+} from "./chunk-ILHJ3OBF.js";
+
+// src/commands/code/domain/errors.ts
+init_esm_shims();
+import { Data } from "effect";
+var LLMError = class extends Data.TaggedError("LLMError") {
+};
+var ParseError = class extends Data.TaggedError("ParseError") {
+};
+var PlanStoreError = class extends Data.TaggedError("PlanStoreError") {
+};
+var SessionStoreError = class extends Data.TaggedError("SessionStoreError") {
+};
+var ProgressStoreError = class extends Data.TaggedError("ProgressStoreError") {
+};
+var GuardrailsStoreError = class extends Data.TaggedError(
+  "GuardrailsStoreError"
+) {
+};
+var OrchestratorError = class extends Data.TaggedError("OrchestratorError") {
+};
+var GitError = class extends Data.TaggedError("GitError") {
+};
+var TokenBudgetError = class extends Data.TaggedError("TokenBudgetError") {
+};
+var RetryExhaustedError = class extends Data.TaggedError(
+  "RetryExhaustedError"
+) {
+};
+var StateStoreError = class extends Data.TaggedError("StateStoreError") {
+};
+var PromptStoreError = class extends Data.TaggedError("PromptStoreError") {
+};
+
+// src/commands/code/domain/schemas/task-generation.ts
+init_esm_shims();
+import { Schema as S } from "effect";
+var GeneratedTaskStatusSchema = S.Literal(
+  "pending",
+  "in_progress",
+  "done",
+  "failed"
+);
+var GeneratedTaskSchema = S.Struct({
+  id: S.String,
+  title: S.String,
+  description: S.String,
+  status: GeneratedTaskStatusSchema,
+  steps: S.Array(S.String)
+});
+var TasksFileSchema = S.Struct({
+  sessionId: S.String,
+  originalTask: S.String,
+  tasks: S.Array(GeneratedTaskSchema)
+});
+function formatTasksJson(tasksFile) {
+  return JSON.stringify(tasksFile, null, 2);
+}
+
+export {
+  LLMError,
+  PlanStoreError,
+  SessionStoreError,
+  ProgressStoreError,
+  GuardrailsStoreError,
+  OrchestratorError,
+  GitError,
+  StateStoreError,
+  PromptStoreError,
+  formatTasksJson
+};

package/dist/chunk-ILHJ3OBF.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.bun/tsup@8.5.1+8346c6f35f8a3409/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/.bun/tsup@8.5.1+8346c6f35f8a3409/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+export {
+  __esm,
+  __export,
+  __toCommonJS,
+  init_esm_shims
+};

package/dist/chunk-XIEB473E.js

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+import {
+  init_esm_shims
+} from "./chunk-ILHJ3OBF.js";
+
+// src/commands/code/orchestrator/prompt.ts
+init_esm_shims();
+var DEFAULT_SYSTEM_PROMPT = `You are executing a ralph loop - an iterative AI coding workflow.
+
+Your output must include structured signals that the orchestrator will parse.
+These signals MUST appear on their own lines, not inside code blocks.
+
+## Signal Format
+
+Use these XML-like tags to communicate structured information:
+
+### Task Breakdown (discovery phase only)
+<ferix:tasks>
+  <task id="1">Brief description of first task</task>
+  <task id="2">Brief description of second task</task>
+</ferix:tasks>
+
+### Phase Planning
+<ferix:phases task="1">
+  <phase id="1.1">First phase description</phase>
+  <phase id="1.2">Second phase description</phase>
+</ferix:phases>
+
+### Success Criteria
+<ferix:criteria task="1">
+  <criterion id="1.c1">First criterion</criterion>
+  <criterion id="1.c2">Second criterion</criterion>
+</ferix:criteria>
+
+### Phase Lifecycle
+<ferix:phase-start id="1.1"/>
+<ferix:phase-done id="1.1"/>
+<ferix:phase-failed id="1.1">reason</ferix:phase-failed>
+
+### Criterion Verification
+<ferix:criterion-passed id="1.c1"/>
+<ferix:criterion-failed id="1.c1" reason="Explanation"/>
+
+### Stage Completion
+<ferix:check-passed/>
+<ferix:check-failed/>
+<ferix:review-complete/>
+<ferix:review-changes-made/>
+
+### Task Completion
+<ferix:task-complete id="1">
+  <summary>Brief summary of what was done</summary>
+  <files-modified>file1.ts, file2.ts</files-modified>
+  <files-created>new-file.ts</files-created>
+</ferix:task-complete>
+
+### Loop Completion (use ONLY when ALL tasks are done)
+<ferix:complete>
+
+\u26A0\uFE0F IMPORTANT: Only emit <ferix:complete> after ALL tasks in the plan are complete.
+After completing a single task, emit <ferix:task-complete> and continue to the next task.
+
+IMPORTANT: Always emit signals on their own lines, never inside markdown code blocks.`;
+var DISCOVERY_SYSTEM_PROMPT = `You are in the DISCOVERY phase of a ralph loop - an iterative AI coding workflow.
+
+Your goal is to:
+1. Generate a short, descriptive name for this session
+2. Analyze the task and break it into SMALL, GRANULAR subtasks
+
+Your output must include these signals that the orchestrator will parse.
+These signals MUST appear on their own lines, not inside code blocks.
+
+## Signal Format
+
+### Session Name (REQUIRED - emit first)
+<ferix:session-name>short-descriptive-name</ferix:session-name>
+
+Guidelines for session name:
+- Use 2-5 words in kebab-case (lowercase with hyphens)
+- Describe the main purpose/feature being worked on
+- Keep it concise but meaningful
+- Examples: "add-dark-mode", "fix-auth-flow", "refactor-api-endpoints", "update-user-profile-ui"
+
+### Task Breakdown (REQUIRED)
+<ferix:tasks>
+  <task id="1">Brief description of first task</task>
+  <task id="2">Brief description of second task</task>
+</ferix:tasks>
+
+## Task Granularity Rules (CRITICAL)
+
+Apply the **"one sentence without 'and'" test**:
+- If describing a task requires "and" to connect unrelated functions, split it
+- Good: "Add login endpoint that validates credentials and returns JWT"
+- Bad: "Handle authentication, user profiles, and billing"
+
+Each task MUST be:
+- Small enough to complete in ONE context window
+- Testable in isolation with automated checks
+- A single logical unit of work
+
+For a typical feature, create 5-15 tasks.
+For complex projects, create 50-200+ discrete tasks.
+
+## CRITICAL: Task Exclusions
+
+Do NOT create tasks for any of the following - these are handled automatically by the orchestrator:
+- Running verification commands (bun lint, bun format, eslint, prettier, etc.)
+- Running tests (bun test, jest, vitest, etc.)
+- Running build commands (bun build, tsc, etc.)
+- Any "Verification", "Testing", or "Testing Plan" sections from PRDs
+- Final cleanup, validation, or quality check steps
+- Commands that just run and check output without changing code
+
+Tasks should ONLY be for implementation work that creates or modifies source code files.
+Verification commands are run automatically after each task completes - do not create tasks for them.
+
+IMPORTANT: Always emit signals on their own lines, never inside markdown code blocks.`;
+var DEFAULT_PLANNING_PROMPT = `## Phase 2: PLANNING
+
+If no phases are defined for the current task, define them now.
+Emit a <ferix:phases> block with the execution phases.`;
+var DEFAULT_EXECUTION_PROMPT = `## Phase 3: EXECUTION
+
+Execute each phase in order:
+1. Emit <ferix:phase-start id="X.Y"/>
+2. Do the work for that phase
+3. Emit <ferix:phase-done id="X.Y"/> or <ferix:phase-failed id="X.Y">reason</ferix:phase-failed>`;
+var DEFAULT_CHECK_PROMPT = `## Phase 4: CHECK
+
+Verify all success criteria are met:
+- For each criterion, emit <ferix:criterion-passed id="X.cY"/> or <ferix:criterion-failed id="X.cY" reason="..."/>
+- Then emit <ferix:check-passed/> or <ferix:check-failed/>`;
+var DEFAULT_REVIEW_PROMPT = `## Phase 6: REVIEW
+
+Review the code for quality:
+- Is it clean and well-organized?
+- Are there any obvious improvements?
+- If you make changes, emit <ferix:review-changes-made/>
+- When done, emit <ferix:review-complete/>`;
+var DEFAULT_COMPLETION_PROMPT = `## Completion
+
+When you finish the CURRENT task, emit:
+<ferix:task-complete id="N">
+  <summary>What was accomplished</summary>
+  <files-modified>list of modified files</files-modified>
+  <files-created>list of new files</files-created>
+</ferix:task-complete>
+
+After emitting task-complete, CONTINUE working on the next pending task.
+
+\u26A0\uFE0F ONLY emit <ferix:complete> when ALL tasks in the plan are done.
+Do NOT emit <ferix:complete> after completing just one task - continue to the next task instead.`;
+function getPhasePrompt(phase, prompts, defaultPrompt) {
+  return prompts?.phases?.[phase] ?? defaultPrompt;
+}
+function buildSystemPrompt(prompts) {
+  return prompts?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+}
+function buildVerifyPrompt(verifyCommands, prompts) {
+  const defaultVerifyPrompt = `## Phase 5: VERIFY
+
+Run these verification commands:
+${verifyCommands.map((cmd) => `- ${cmd}`).join("\n")}
+
+If any fail, fix the issues and re-verify.
+
+IMPORTANT: Once ALL verification commands pass:
+- Emit <ferix:task-complete id="N"> with a summary of what was done
+- If this was the last task, also emit <ferix:complete>
+- Do NOT run verification again after it passes`;
+  return prompts?.phases?.verify ?? defaultVerifyPrompt;
+}
+var TASK_STATUS_ICONS = {
+  done: "[x]",
+  in_progress: "[~]",
+  pending: "[ ]",
+  planning: "[~]",
+  failed: "[!]",
+  skipped: "[-]"
+};
+function buildTaskListSection(plan) {
+  if (plan.tasks.length === 0) {
+    return "";
+  }
+  const completedCount = plan.tasks.filter((t) => t.status === "done").length;
+  const totalCount = plan.tasks.length;
+  const lines = [
+    "## Task Progress",
+    "",
+    `Status: ${completedCount}/${totalCount} complete`,
+    ""
+  ];
+  const currentTaskId = plan.tasks.find(
+    (t) => t.status === "in_progress" || t.status === "pending"
+  )?.id;
+  for (const task of plan.tasks) {
+    const icon = TASK_STATUS_ICONS[task.status];
+    const currentMarker = task.id === currentTaskId ? " \u2190 current" : "";
+    lines.push(
+      `- ${icon} Task ${task.id}: ${task.title} (${task.status})${currentMarker}`
+    );
+  }
+  return lines.join("\n");
+}
+function buildCurrentTaskSection(plan) {
+  const currentTask = plan.tasks.find(
+    (t) => t.status === "in_progress" || t.status === "pending"
+  );
+  if (!currentTask) {
+    return void 0;
+  }
+  const phasesSection = currentTask.phases.length > 0 ? `### Phases
+${currentTask.phases.map((p) => `- ${p.id}: ${p.description} (${p.status})`).join("\n")}` : "No phases defined yet. Emit a <ferix:phases> block to define phases.";
+  const criteriaSection = currentTask.criteria.length > 0 ? `### Success Criteria
+${currentTask.criteria.map((c) => `- ${c.id}: ${c.description} (${c.status})`).join("\n")}` : "";
+  return `## Current Task
+
+Task ${currentTask.id}: ${currentTask.title}
+
+${currentTask.description}
+
+${phasesSection}
+
+${criteriaSection}`;
+}
+function buildDiscoveryPrompt(config) {
+  const sections = [];
+  sections.push(DISCOVERY_SYSTEM_PROMPT);
+  if (config.prompts?.additionalContext) {
+    sections.push(
+      `## Additional Context
+
+${config.prompts.additionalContext}`
+    );
+  }
+  sections.push(`## Task
+
+${config.task}`);
+  sections.push(`## Instructions
+
+Analyze the task above and:
+
+1. **Generate a session name** (2-5 words, kebab-case)
+   - Should describe the main purpose of this work
+   - Emit: <ferix:session-name>your-descriptive-name</ferix:session-name>
+
+2. **Break the task into logical subtasks** (2-6 tasks)
+   - Read and understand what needs to be done
+   - Identify the main components or steps
+   - Emit: <ferix:tasks>...</ferix:tasks>
+
+Each task should be:
+- Self-contained and independently verifiable
+- Clear and specific
+- Ordered logically (dependencies first)
+- ONLY for code implementation (NOT for running lint/test/build commands)
+
+REMINDER: Do NOT create tasks for verification steps like "Run lint", "Run tests", "Verify changes", etc.
+The orchestrator handles verification automatically after each task completes.
+If the PRD has a "Verification" or "Testing" section, IGNORE it when creating tasks.
+
+Begin your analysis now.`);
+  return sections.join("\n\n");
+}
+function buildPrompt(config, iteration, plan) {
+  const prompts = config.prompts;
+  const sections = [];
+  sections.push(buildSystemPrompt(prompts));
+  if (prompts?.additionalContext) {
+    sections.push(`## Additional Context
+
+${prompts.additionalContext}`);
+  }
+  sections.push(`## Task
+
+${config.task}`);
+  if (plan && plan.tasks.length > 0) {
+    const taskListSection = buildTaskListSection(plan);
+    if (taskListSection) {
+      sections.push(taskListSection);
+    }
+    const taskSection = buildCurrentTaskSection(plan);
+    if (taskSection) {
+      sections.push(taskSection);
+    }
+  }
+  sections.push(getPhasePrompt("planning", prompts, DEFAULT_PLANNING_PROMPT));
+  sections.push(getPhasePrompt("execution", prompts, DEFAULT_EXECUTION_PROMPT));
+  sections.push(getPhasePrompt("check", prompts, DEFAULT_CHECK_PROMPT));
+  if (config.verifyCommands.length > 0 && plan && !areAllTasksComplete(plan)) {
+    const currentTask = plan.tasks.find(
+      (t) => t.status === "in_progress" || t.status === "pending"
+    );
+    if (currentTask) {
+      sections.push(buildVerifyPrompt(config.verifyCommands, prompts));
+    }
+  }
+  sections.push(getPhasePrompt("review", prompts, DEFAULT_REVIEW_PROMPT));
+  sections.push(
+    getPhasePrompt("completion", prompts, DEFAULT_COMPLETION_PROMPT)
+  );
+  sections.push(`---
+
+Iteration ${iteration} of ${config.maxIterations || "unlimited"}
+
+Begin.`);
+  return sections.join("\n\n");
+}
+function areAllTasksComplete(plan) {
+  if (!plan || plan.tasks.length === 0) {
+    return false;
+  }
+  return plan.tasks.every((t) => t.status === "done" || t.status === "skipped");
+}
+function buildSessionState(config, iteration, sessionId, plan, recentProgress = []) {
+  const currentTask = plan?.tasks.find(
+    (t) => t.status === "in_progress" || t.status === "pending"
+  );
+  const taskSummary = plan ? {
+    total: plan.tasks.length,
+    done: plan.tasks.filter((t) => t.status === "done").length,
+    inProgress: plan.tasks.filter((t) => t.status === "in_progress").length,
+    pending: plan.tasks.filter(
+      (t) => t.status === "pending" || t.status === "planning"
+    ).length
+  } : { total: 0, done: 0, inProgress: 0, pending: 0 };
+  return {
+    sessionId,
+    originalTask: config.task,
+    iteration,
+    maxIterations: config.maxIterations,
+    taskSummary,
+    currentTask: currentTask ? {
+      id: currentTask.id,
+      title: currentTask.title,
+      description: currentTask.description,
+      phases: currentTask.phases.map((p) => ({
+        id: p.id,
+        description: p.description,
+        status: p.status
+      })),
+      criteria: currentTask.criteria.map((c) => ({
+        id: c.id,
+        description: c.description,
+        status: c.status
+      }))
+    } : null,
+    recentProgress
+  };
+}
+
+export {
+  buildDiscoveryPrompt,
+  buildPrompt,
+  areAllTasksComplete,
+  buildSessionState
+};