agentic-forge 0.0.0

package/src/templates/plan-chore.md.j2

@@ -0,0 +1,27 @@
+# Chore Plan: {{ title }}
+
+Created: {{ created }}
+Status: {{ status }}
+Workflow: {{ workflow_id }}
+
+## Summary
+
+{{ summary }}
+
+## Tasks
+
+{% for task in tasks %}
+- [{% if task.completed %}x{% else %} {% endif %}] {{ task.description }}
+{% endfor %}
+
+## Affected Files
+
+{% for file in affected_files %}
+- {{ file }}
+{% endfor %}
+
+{% if notes %}
+## Notes
+
+{{ notes }}
+{% endif %}

package/src/templates/plan-feature.md.j2

@@ -0,0 +1,41 @@
+# Feature Plan: {{ title }}
+
+Created: {{ created }}
+Status: {{ status }}
+Workflow: {{ workflow_id }}
+
+## Summary
+
+{{ summary }}
+
+## Progress Tracker
+
+{% for milestone in milestones %}
+### Milestone {{ milestone.id }}: {{ milestone.title }}
+
+Complexity: {{ milestone.complexity }}
+
+{% for task in milestone.tasks %}
+- [{% if task.completed %}x{% else %} {% endif %}] {{ task.id }}: {{ task.description }}
+  {%- if task.files %} ({{ task.files | join(", ") }}){% endif %}
+{% endfor %}
+
+{% endfor %}
+
+## Affected Files
+
+{% for file in affected_files %}
+- {{ file }}
+{% endfor %}
+
+## Dependencies
+
+{% for dep in dependencies %}
+- {{ dep }}
+{% endfor %}
+
+## Risks & Considerations
+
+{% for risk in risks %}
+- {{ risk }}
+{% endfor %}

package/src/templates/progress.json.j2

@@ -0,0 +1,16 @@
+{
+  "schema_version": "1.0",
+  "workflow_id": "{{ workflow_id }}",
+  "workflow_name": "{{ workflow_name }}",
+  "status": "{{ status }}",
+  "started_at": "{{ started_at }}",
+  "completed_at": {{ completed_at | tojson if completed_at else "null" }},
+  "current_step": {{ current_step | tojson if current_step else "null" }},
+  "completed_steps": {{ completed_steps | tojson }},
+  "pending_steps": {{ pending_steps | tojson }},
+  "running_steps": {{ running_steps | tojson }},
+  "parallel_branches": {{ parallel_branches | tojson }},
+  "errors": {{ errors | tojson }},
+  "variables": {{ variables | tojson }},
+  "step_outputs": {{ step_outputs | tojson }}
+}

package/src/templates/ralph-report.md.j2

@@ -0,0 +1,45 @@
+# Ralph Wiggum Loop Report
+
+Generated: {{ workflow.completed_at }}
+Workflow: {{ workflow.name }}
+ID: {{ workflow.id | default(workflow.workflow_id, true) }}
+
+## Summary
+
+**Status**: {{ workflow.status | default('completed') }}
+**Started**: {{ workflow.started_at }}
+**Completed**: {{ workflow.completed_at }}
+
+## Task
+
+{% if inputs.task %}
+{{ inputs.task }}
+{% else %}
+_No task description provided_
+{% endif %}
+
+## Loop Execution
+
+| Step | Status | Iterations | Summary |
+|------|--------|------------|---------|
+{% for step_name, step in steps.items() %}
+| {{ step_name }} | {{ step.status }} | {{ step.output_summary | default('-') | truncate(80) }} |
+{% endfor %}
+
+## Final Output
+
+{% for step_name, step in steps.items() %}
+{% if step.output %}
+### {{ step_name }}
+
+{{ step.output }}
+{% endif %}
+{% endfor %}
+
+{% if files_changed %}
+## Files Changed
+
+{% for file in files_changed %}
+- `{{ file }}`
+{% endfor %}
+{% endif %}

package/src/types.ts

@@ -0,0 +1,141 @@
+/** Core types for agentic-forge workflow engine. */
+
+// --- Step types ---
+
+export type StepType =
+	| "prompt"
+	| "parallel"
+	| "serial"
+	| "conditional"
+	| "ralph-loop"
+	| "wait-for-human";
+
+export const VALID_STEP_TYPES: StepType[] = [
+	"prompt",
+	"parallel",
+	"serial",
+	"conditional",
+	"ralph-loop",
+	"wait-for-human",
+];
+
+// --- Workflow definition types ---
+
+export interface Variable {
+	name: string;
+	type: string;
+	required: boolean;
+	default?: unknown;
+	description?: string;
+}
+
+export interface GitSettings {
+	enabled: boolean;
+	worktree: boolean;
+	autoCommit: boolean;
+	autoPr: boolean;
+	branchPrefix: string;
+}
+
+export interface StepGitSettings {
+	worktree: boolean;
+	autoPr: boolean;
+	branchPrefix: string;
+}
+
+export interface WorkflowSettings {
+	maxRetry: number;
+	timeoutMinutes: number;
+	trackProgress: boolean;
+	autofix: string;
+	terminalOutput: string;
+	bypassPermissions: boolean;
+	strictMode: boolean;
+	model: string | null;
+	requiredTools: string[];
+	git: GitSettings;
+}
+
+export interface StepDefinition {
+	name: string;
+	type: StepType;
+	prompt?: string | null;
+	agent?: string | null;
+	steps: StepDefinition[];
+	mergeStrategy: string;
+	mergeMode: string;
+	condition?: string | null;
+	thenSteps: StepDefinition[];
+	elseSteps: StepDefinition[];
+	maxIterations: number | string;
+	completionPromise?: string | null;
+	message?: string | null;
+	pollingInterval: number;
+	onTimeout: string;
+	model?: string | null;
+	stepTimeoutMinutes?: number | null;
+	stepMaxRetry?: number | null;
+	onError: string;
+	checkpoint: boolean;
+	dependsOn?: string | null;
+	git?: StepGitSettings | null;
+}
+
+export interface OutputDefinition {
+	name: string;
+	template: string;
+	path: string;
+	when: string;
+}
+
+export interface WorkflowDefinition {
+	name: string;
+	version: string;
+	description: string;
+	settings: WorkflowSettings;
+	variables: Variable[];
+	steps: StepDefinition[];
+	outputs: OutputDefinition[];
+}
+
+// --- Progress tracking types ---
+
+export type WorkflowStatus = "pending" | "running" | "completed" | "failed" | "paused" | "canceled";
+
+export type StepStatus = "pending" | "running" | "completed" | "failed" | "skipped";
+
+export interface StepProgress {
+	name: string;
+	status: string;
+	startedAt: string | null;
+	completedAt: string | null;
+	retryCount: number;
+	outputSummary: string;
+	error: string | null;
+	humanInput: string | null;
+}
+
+export interface ParallelBranch {
+	branchId: string;
+	status: string;
+	worktreePath: string;
+	progressFile: string;
+}
+
+export interface WorkflowProgress {
+	schemaVersion: string;
+	workflowId: string;
+	workflowName: string;
+	status: string;
+	startedAt: string | null;
+	completedAt: string | null;
+	currentStep: Record<string, unknown> | null;
+	completedSteps: StepProgress[];
+	pendingSteps: string[];
+	runningSteps: string[];
+	parallelBranches: ParallelBranch[];
+	errors: Record<string, unknown>[];
+	variables: Record<string, unknown>;
+	stepOutputs: Record<string, unknown>;
+	workflowFile: string;
+}

package/src/workflows/analyze-codebase-merge.yaml

@@ -0,0 +1,328 @@
+name: analyze-codebase-merge
+version: "1.0"
+description: Run comprehensive codebase analysis with autofix, merge branches, review, and create PR
+
+settings:
+  max-retry: 2
+  timeout-minutes: 180
+  track-progress: true
+  terminal-output: base
+  git:
+    enabled: true
+    worktree: true
+    auto-commit: true
+    branch-prefix: "agentic/analysis"
+
+variables:
+  - name: autofix
+    type: string
+    required: false
+    default: "major"
+    description: Severity level for automatic fixes (none, minor, major, critical)
+  - name: fix_severity
+    type: string
+    required: false
+    default: "major"
+    description: Minimum severity for validation auto-fix
+  - name: paths
+    type: string
+    required: false
+    default: ""
+    description: Space-separated list of paths to analyze (optional)
+  - name: create_pr
+    type: boolean
+    required: false
+    default: false
+    description: Whether to create a PR after all changes are merged
+  - name: max_fix_iterations
+    type: number
+    required: false
+    default: 25
+    description: Maximum iterations per analysis type for fixing issues
+
+steps:
+  - name: analyze-and-fix-all
+    type: parallel
+    merge-strategy: wait-all
+    merge-mode: merge
+    git:
+      worktree: true
+      branch-prefix: "agentic/analysis"
+    steps:
+      - name: bug-analysis
+        type: serial
+        steps:
+          - name: analyze-bug
+            type: prompt
+            prompt: /af-analyze bug {{ variables.paths }}
+
+          - name: fix-bug
+            type: conditional
+            condition: "variables.autofix != 'none'"
+            then:
+              - name: apply-bug-fixes
+                type: ralph-loop
+                max-iterations: "{{ variables.max_fix_iterations }}"
+                completion-promise: "BUG_FIXES_COMPLETE"
+                model: sonnet
+                timeout-minutes: 30
+                prompt: |
+                  ## Task
+                  Fix issues from the bug analysis document.
+
+                  ## Instructions
+                  1. Read the analysis document at agentic/analysis/bug.md
+                  2. If the document does not exist or has no unfixed issues, return the completion promise
+                  3. Pick the NEXT unfixed issue (highest severity first, must be {{ variables.autofix }} or higher)
+                  4. Navigate the code to understand the issue context
+                  5. Implement the fix
+                  6. Run build/lint commands and fix any errors
+                  7. Mark the issue as fixed in the analysis document
+                  8. Commit using git-commit with title starting with issue ID
+                  9. End this session (do NOT continue to next issue)
+
+                  ## Completion
+                  When ALL issues with severity {{ variables.autofix }} or higher are fixed OR the document doesn't exist, output:
+                  ```json
+                  {"ralph_complete": true, "promise": "BUG_FIXES_COMPLETE"}
+                  ```
+
+                  IMPORTANT:
+                  - Fix only ONE issue per iteration, then end session
+                  - If an issue cannot be fixed (error, missing data), mark as skipped with reason
+                  - Only return completion promise when genuinely done
+
+      - name: debt-analysis
+        type: serial
+        steps:
+          - name: analyze-debt
+            type: prompt
+            prompt: /af-analyze debt {{ variables.paths }}
+
+          - name: fix-debt
+            type: conditional
+            condition: "variables.autofix != 'none'"
+            then:
+              - name: apply-debt-fixes
+                type: ralph-loop
+                max-iterations: "{{ variables.max_fix_iterations }}"
+                completion-promise: "DEBT_FIXES_COMPLETE"
+                model: sonnet
+                timeout-minutes: 30
+                prompt: |
+                  ## Task
+                  Fix issues from the technical debt analysis document.
+
+                  ## Instructions
+                  1. Read the analysis document at agentic/analysis/debt.md
+                  2. If the document does not exist or has no unfixed issues, return the completion promise
+                  3. Pick the NEXT unfixed issue (highest severity first, must be {{ variables.autofix }} or higher)
+                  4. Navigate the code to understand the issue context
+                  5. Implement the fix
+                  6. Run build/lint commands and fix any errors
+                  7. Mark the issue as fixed in the analysis document
+                  8. Commit using git-commit with title starting with issue ID
+                  9. End this session (do NOT continue to next issue)
+
+                  ## Completion
+                  When ALL issues with severity {{ variables.autofix }} or higher are fixed OR the document doesn't exist, output:
+                  ```json
+                  {"ralph_complete": true, "promise": "DEBT_FIXES_COMPLETE"}
+                  ```
+
+                  IMPORTANT:
+                  - Fix only ONE issue per iteration, then end session
+                  - If an issue cannot be fixed (error, missing data), mark as skipped with reason
+                  - Only return completion promise when genuinely done
+
+      - name: doc-analysis
+        type: serial
+        steps:
+          - name: analyze-doc
+            type: prompt
+            prompt: /af-analyze doc {{ variables.paths }}
+
+          - name: fix-doc
+            type: conditional
+            condition: "variables.autofix != 'none'"
+            then:
+              - name: apply-doc-fixes
+                type: ralph-loop
+                max-iterations: "{{ variables.max_fix_iterations }}"
+                completion-promise: "DOC_FIXES_COMPLETE"
+                model: sonnet
+                timeout-minutes: 30
+                prompt: |
+                  ## Task
+                  Fix issues from the documentation analysis document.
+
+                  ## Instructions
+                  1. Read the analysis document at agentic/analysis/doc.md
+                  2. If the document does not exist or has no unfixed issues, return the completion promise
+                  3. Pick the NEXT unfixed issue (highest severity first, must be {{ variables.autofix }} or higher)
+                  4. Navigate the code to understand the issue context
+                  5. Implement the fix
+                  6. Run build/lint commands and fix any errors
+                  7. Mark the issue as fixed in the analysis document
+                  8. Commit using git-commit with title starting with issue ID
+                  9. End this session (do NOT continue to next issue)
+
+                  ## Completion
+                  When ALL issues with severity {{ variables.autofix }} or higher are fixed OR the document doesn't exist, output:
+                  ```json
+                  {"ralph_complete": true, "promise": "DOC_FIXES_COMPLETE"}
+                  ```
+
+                  IMPORTANT:
+                  - Fix only ONE issue per iteration, then end session
+                  - If an issue cannot be fixed (error, missing data), mark as skipped with reason
+                  - Only return completion promise when genuinely done
+
+      - name: security-analysis
+        type: serial
+        steps:
+          - name: analyze-security
+            type: prompt
+            prompt: /af-analyze security {{ variables.paths }}
+
+          - name: fix-security
+            type: conditional
+            condition: "variables.autofix != 'none'"
+            then:
+              - name: apply-security-fixes
+                type: ralph-loop
+                max-iterations: "{{ variables.max_fix_iterations }}"
+                completion-promise: "SECURITY_FIXES_COMPLETE"
+                model: sonnet
+                timeout-minutes: 30
+                prompt: |
+                  ## Task
+                  Fix issues from the security analysis document.
+
+                  ## Instructions
+                  1. Read the analysis document at agentic/analysis/security.md
+                  2. If the document does not exist or has no unfixed issues, return the completion promise
+                  3. Pick the NEXT unfixed issue (highest severity first, must be {{ variables.autofix }} or higher)
+                  4. Navigate the code to understand the issue context
+                  5. Implement the fix
+                  6. Run build/lint commands and fix any errors
+                  7. Mark the issue as fixed in the analysis document
+                  8. Commit using git-commit with title starting with issue ID
+                  9. End this session (do NOT continue to next issue)
+
+                  ## Completion
+                  When ALL issues with severity {{ variables.autofix }} or higher are fixed OR the document doesn't exist, output:
+                  ```json
+                  {"ralph_complete": true, "promise": "SECURITY_FIXES_COMPLETE"}
+                  ```
+
+                  IMPORTANT:
+                  - Fix only ONE issue per iteration, then end session
+                  - If an issue cannot be fixed (error, missing data), mark as skipped with reason
+                  - Only return completion promise when genuinely done
+
+      - name: style-analysis
+        type: serial
+        steps:
+          - name: analyze-style
+            type: prompt
+            prompt: /af-analyze style {{ variables.paths }}
+
+          - name: fix-style
+            type: conditional
+            condition: "variables.autofix != 'none'"
+            then:
+              - name: apply-style-fixes
+                type: ralph-loop
+                max-iterations: "{{ variables.max_fix_iterations }}"
+                completion-promise: "STYLE_FIXES_COMPLETE"
+                model: sonnet
+                timeout-minutes: 30
+                prompt: |
+                  ## Task
+                  Fix issues from the style analysis document.
+
+                  ## Instructions
+                  1. Read the analysis document at agentic/analysis/style.md
+                  2. If the document does not exist or has no unfixed issues, return the completion promise
+                  3. Pick the NEXT unfixed issue (highest severity first, must be {{ variables.autofix }} or higher)
+                  4. Navigate the code to understand the issue context
+                  5. Implement the fix
+                  6. Run build/lint commands and fix any errors
+                  7. Mark the issue as fixed in the analysis document
+                  8. Commit using git-commit with title starting with issue ID
+                  9. End this session (do NOT continue to next issue)
+
+                  ## Completion
+                  When ALL issues with severity {{ variables.autofix }} or higher are fixed OR the document doesn't exist, output:
+                  ```json
+                  {"ralph_complete": true, "promise": "STYLE_FIXES_COMPLETE"}
+                  ```
+
+                  IMPORTANT:
+                  - Fix only ONE issue per iteration, then end session
+                  - If an issue cannot be fixed (error, missing data), mark as skipped with reason
+                  - Only return completion promise when genuinely done
+
+  - name: review-merged-changes
+    type: prompt
+    prompt: /af-sdlc-review "" {{ variables.fix_severity }}
+
+  - name: fix-validation-issues
+    type: conditional
+    condition: "variables.fix_severity != 'none'"
+    then:
+      - name: apply-validation-fixes
+        type: ralph-loop
+        max-iterations: "{{ variables.max_fix_iterations }}"
+        completion-promise: "VALIDATION_FIXES_COMPLETE"
+        model: sonnet
+        timeout-minutes: 30
+        prompt: |
+          ## Task
+          Fix validation issues from the merged analysis changes.
+
+          ## Instructions
+          1. Run validation checks (tests, build, lint)
+          2. If all checks pass, return the completion promise
+          3. Pick the NEXT failing check (tests first, then build, then lint)
+          4. Navigate the code to understand the failure
+          5. Implement the fix
+          6. Run the failing check again to verify
+          7. Commit using git-commit with clear message
+          8. End this session (do NOT continue to next issue)
+
+          ## Checks to Run
+          - Run the test suite and fix failing tests
+          - Run the build and fix any build errors
+          - Run linting and fix style issues
+          - Verify all changes follow project conventions
+
+          ## Completion
+          When ALL validation checks pass, output:
+          ```json
+          {"ralph_complete": true, "promise": "VALIDATION_FIXES_COMPLETE"}
+          ```
+
+          IMPORTANT:
+          - Fix only ONE issue per iteration, then end session
+          - If an issue cannot be fixed (error, missing data), mark as skipped with reason
+          - Only return completion promise when genuinely done
+
+      - name: re-review
+        type: prompt
+        prompt: /af-sdlc-review "" {{ variables.fix_severity }}
+
+  - name: create-pr
+    type: conditional
+    condition: "variables.create_pr"
+    then:
+      - name: open-pr
+        type: prompt
+        prompt: /af-git-pr "[Analysis] Codebase analysis and fixes"
+
+outputs:
+  - name: analysis-summary
+    template: analysis-summary.md.j2
+    path: summary.md
+    when: completed