fraim-framework 2.0.47 → 2.0.49

package/dist/registry/ai-manager-rules/implement-phases/implement-code.md

@@ -177,19 +177,16 @@ Tag tests appropriately to ensure proper test suite execution:
 - **`unit`**: Tests that verify individual functions or classes in isolation
 - **`e2e`**: End-to-end tests that verify complete user workflows
 
-**Smoke Test Execution Rules:**
-If ANY tests are tagged "smoke" or you're modifying core functionality:
-1. **MANDATORY**: Run full smoke test suite: `npm run test-smoke-ci`
-2. **MANDATORY**: Include smoke test output in evidence
-3. **MANDATORY**: All smoke tests must pass before proceeding
-4. **BLOCKING**: Smoke test failures block phase completion
-
 ### Step 7: Basic Compilation Check
 
 **Verify code compiles:**
-```bash
-npx tsc --noEmit --skipLibCheck
-```
+
+**Build Commands**: Always check `.fraim/config.json` first for `customizations.validation.buildCommand`, use that if available, otherwise default to `npm run build`.
+
+**What to Look For**:
+- Exit code 0 (success)
+- No TypeScript compilation errors
+- Clean build output
 
 **Must exit with code 0** (no errors)
 

package/dist/registry/ai-manager-rules/implement-phases/implement-smoke.md

@@ -23,16 +23,17 @@ All technical checks pass, confirming:
 
 ### Step 0: Read Project Validation Commands 📖
 
-**FIRST**: Read your project's validation commands from `.fraim/config.json`:
+**FIRST**: Check your project's custom commands:
 
 ```bash
-# Read the config to get project-specific validation commands
-cat .fraim/config.json
-```
+# Check for custom build command
+cat .fraim/config.json | grep -A 3 "buildCommand"
 
-Look for `customizations.validation.buildCommand` and `customizations.validation.smokeTestCommand`.
+# Check for custom smoke test command  
+cat .fraim/config.json | grep -A 3 "smokeTestCommand"
+```
 
-**Use these commands instead of the generic ones below if they exist.**
+**Use the configured commands if they exist, otherwise use the defaults shown below.**
 
 ### Step 1: Build Compilation Check ✅
 
@@ -43,7 +44,9 @@ Look for `customizations.validation.buildCommand` and `customizations.validation
 
 **Commands to Run** (use customizations.validation.buildCommand from config if available):
 ```bash
-# Run build (use customizations.validation.buildCommand if available, otherwise default)
+# Use project-specific build command from .fraim/config.json if available:
+# - Look for customizations.validation.buildCommand
+# - Use that command if available, otherwise default to:
 npm run build
 ```
 
@@ -164,6 +167,7 @@ npm run build && npm test && git status
 
 ### Technical Standards
 - Read `.fraim/config.json` for the architecture document path (`customizations.architectureDoc`), then read the local architecture document to understand the full technical standards
+- **Config Commands**: Always check `.fraim/config.json` first for `customizations.validation.buildCommand` and `customizations.validation.smokeTestCommand`, use those if available, otherwise use defaults
 - Use Successful Debugging Patterns from `rules/successful-debugging-patterns.md` via `get_fraim_file`
 - When using git commands directly (if MCP tools unavailable), read `rules/git-safe-commands.md` via `get_fraim_file`
 
@@ -181,6 +185,9 @@ npm run build && npm test && git status
 
 **Run smoke tests specifically:**
 ```bash
+# Use project-specific command from .fraim/config.json if available
+# Check: cat .fraim/config.json | grep "smokeTestCommand"
+# Use configured command or default to:
 npm run test-smoke-ci
 ```
 

package/dist/registry/ai-manager-rules/implement-phases/implement-validate.md

@@ -18,6 +18,10 @@ This is THE critical phase where you prove your implementation actually works. N
 
 ## RULES FOR THIS PHASE
 
+### Config-Aware Testing
+**CRITICAL**: Always check `.fraim/config.json` first for project-specific test commands:
+- `customizations.validation.testSuiteCommand` - Use this for comprehensive testing (default: `npm test`)
+
 ### Success Criteria
 Read `registry/rules/agent-success-criteria.md` via `get_fraim_file` for the complete framework. Focus on:
 - **Integrity** (honest reporting of validation results - never claim something works if you didn't test it)
@@ -86,17 +90,17 @@ grep -r "as any" src/ || echo "✅ No type bypassing found"
 
 **Commands to Run** (check .fraim/config.json for project-specific commands first):
 ```bash
-# 1. FIRST: Read your project's validation commands from .fraim/config.json
-cat .fraim/config.json | grep -A 10 "validation"
+# 1. FIRST: Check for custom test commands
+cat .fraim/config.json | grep -A 5 "validation"
 
-# 2. Run the comprehensive test suite (this runs ALL tests)
+# 2. Run comprehensive test suite for current work
+# Use customizations.validation.testSuiteCommand if available, otherwise:
 npm test
 
-# 3. Also run smoke tests specifically to verify core functionality
-npm run test-smoke-ci
-
-# 4. Run all tests in CI mode for complete coverage
-npm run test-all-ci
+# 3. Run targeted tests for your specific changes (if applicable)
+# Example: If you modified user authentication, run auth-related tests
+# npm run test -- --grep "auth"
+# OR: npm run test test-{issue-number}-*.ts
 ```
 
 **What to Look For**:

package/dist/registry/ai-manager-rules/shared-phases/address-pr-feedback.md

@@ -0,0 +1,188 @@
+# Phase: address-pr-feedback
+
+## INTENT
+To systematically address all PR feedback items by making targeted changes, replying to comments, and preparing for re-validation.
+
+## OUTCOME
+All PR feedback addressed with:
+- Targeted changes made for each feedback item
+- Feedback file updated with resolutions
+- PR comments replied to with explanations
+- Changes validated and ready for re-review
+
+## RULES FOR THIS PHASE
+
+### Success Criteria
+Read `registry/rules/agent-success-criteria.md` via `get_fraim_file` for the complete framework. Focus especially on:
+- **Integrity** (document all changes made)
+- **Correctness** (address feedback accurately)
+- **Completeness** (address every UNADDRESSED item)
+
+### Simplicity Principles
+Read `registry/rules/simplicity.md` via `get_fraim_file` for complete guidelines. Critical for feedback phase:
+- **Targeted Changes**: Make minimal changes to address specific feedback
+- **Manual Validation**: Test changes manually before updating PR
+- **Clear Communication**: Reply to each comment with clear explanations
+
+## PRINCIPLES
+- **Feedback-Driven**: Address only the specific issues raised in PR comments
+- **Minimal Changes**: Avoid scope creep or unnecessary refactoring
+- **Clear Communication**: Explain resolutions clearly to reviewers
+- **Validation**: Ensure changes work before updating PR
+
+## 📋 WORKFLOW
+
+### Step 1: Read PR Feedback File
+
+**MANDATORY**: Read the feedback file created by `wait-for-pr-review`:
+- File location: `docs/evidence/{issue_number}-{workflow_type}-feedback.md`
+- Identify all UNADDRESSED feedback items
+- Understand the context and requirements for each item
+
+### Step 2: Address Each Feedback Item
+
+**For each UNADDRESSED item:**
+
+1. **Understand the Feedback**:
+   - Read the comment carefully
+   - Identify what specific change is requested
+   - Determine the scope of the change needed
+
+2. **Make Targeted Changes**:
+   - Make minimal, focused changes to address the specific feedback
+   - Avoid unrelated changes or improvements
+   - Keep changes as small as possible while fully addressing the feedback
+
+3. **Update Feedback File**:
+   - Change status from UNADDRESSED to ADDRESSED
+   - Document your resolution approach
+   - Include details of what you changed
+
+**Feedback File Update Format**:
+```markdown
+### Comment X - ADDRESSED
+- **Author**: reviewer_name
+- **Type**: pr_comment|review_comment|review
+- **File**: file_path (if applicable)
+- **Line**: line_number (if applicable)
+- **Comment**: Original feedback text
+- **Status**: ADDRESSED
+- **Resolution**: Detailed explanation of how you addressed this feedback
+- **Changes Made**: Specific files/lines modified
+```
+
+### Step 3: Validate Changes
+
+**Test your changes:**
+- Run compilation check: `npx tsc --noEmit --skipLibCheck`
+- Run relevant tests to ensure no regressions
+- Test manually if the feedback involves UI/API behavior
+- Verify the specific issue mentioned in feedback is resolved
+
+### Step 4: Reply to PR Comments
+
+**For each addressed comment:**
+- Reply to the original PR comment
+- Explain what you changed and how it addresses their concern
+- Reference specific files/lines if helpful
+- Be clear and professional in your communication
+
+**Example reply format**:
+```
+✅ **Addressed**: [Brief description of what you changed]
+
+**Changes made**:
+- [Specific change 1]
+- [Specific change 2]
+
+**Files modified**: `path/to/file.ts`, `path/to/test.ts`
+
+This should resolve the [specific issue mentioned]. Please let me know if you need any clarification!
+```
+
+### Step 5: Commit and Push Changes
+
+**Commit your changes:**
+- Use clear commit messages that reference the feedback
+- Example: `Address PR feedback: Fix error handling in auth service`
+- Push changes to the PR branch
+
+## 📸 EVIDENCE REQUIREMENTS
+
+You MUST provide concrete evidence for all claims:
+
+1. **All Feedback Addressed**: Every UNADDRESSED item in feedback file is now ADDRESSED
+2. **Changes Made**: Specific code changes made for each feedback item
+3. **Validation Complete**: Tests pass and changes work as expected
+4. **PR Updated**: Changes committed, pushed, and comments replied to
+
+## VALIDATION
+
+### Phase Complete When:
+- ✅ All UNADDRESSED items in feedback file are now ADDRESSED
+- ✅ Feedback file updated with resolution details for each item
+- ✅ Targeted changes made to address each specific feedback
+- ✅ Changes validated (compilation, tests, manual testing)
+- ✅ PR comments replied to with clear explanations
+- ✅ Changes committed and pushed to PR branch
+
+### Phase Incomplete If:
+- ❌ Any UNADDRESSED items remain in feedback file
+- ❌ Changes don't actually address the feedback given
+- ❌ Tests failing after changes
+- ❌ Compilation errors introduced
+- ❌ PR comments not replied to
+- ❌ Changes not committed/pushed
+
+### Report Back:
+When you complete this phase, call:
+
+```javascript
+seekCoachingOnNextStep({
+  workflowType: "{workflow_type}",
+  issueNumber: "{issue_number}",
+  currentPhase: "address-pr-feedback",
+  status: "complete",
+  findings: {
+    feedbackItemsAddressed: {total_items_addressed},
+    changesValidated: true
+  },
+  evidence: {
+    feedbackFileUpdated: "All UNADDRESSED items now ADDRESSED with resolutions",
+    changesMade: "Brief summary of changes made",
+    validationResults: "Compilation and tests pass",
+    prCommentsReplied: "Replied to all PR comments with explanations"
+  }
+})
+```
+
+If feedback addressing incomplete, iterate:
+```javascript
+seekCoachingOnNextStep({
+  workflowType: "{workflow_type}",
+  issueNumber: "{issue_number}",
+  currentPhase: "address-pr-feedback",
+  status: "incomplete",
+  findings: {
+    uncertainties: ["Issues encountered", "What needs to be fixed"]
+  }
+})
+```
+
+## SCRIPTS
+
+**Compile TypeScript:**
+```bash
+npx tsc --noEmit --skipLibCheck
+```
+
+**Run tests:**
+```bash
+npm test
+```
+
+**Check git status:**
+```bash
+git status
+git diff
+```

package/dist/registry/providers/ado.json

@@ -0,0 +1,19 @@
+{
+  "get_issue": "mcp_ado_get_work_item({ organization: '{{repository.organization}}', project: '{{repository.project}}', workItemId: {{issue_number}} })",
+  "update_issue_status": "mcp_ado_update_work_item({ organization: '{{repository.organization}}', project: '{{repository.project}}', workItemId: {{issue_number}}, state: 'Active' })",
+  "create_pr": "mcp_ado_create_pull_request({ organization: '{{repository.organization}}', project: '{{repository.project}}', repository: '{{repository.name}}', title: '{{title}}', sourceBranch: '{{branch}}', targetBranch: 'main', description: '{{body}}' })",
+  "get_pr": "mcp_ado_get_pull_request({ organization: '{{repository.organization}}', project: '{{repository.project}}', repository: '{{repository.name}}', pullRequestId: {{pr_number}} })",
+  "get_pr_comments": "mcp_ado_get_pr_comments({ organization: '{{repository.organization}}', project: '{{repository.project}}', repository: '{{repository.name}}', pullRequestId: {{pr_number}} })",
+  "get_pr_review_comments": "mcp_ado_get_pr_review_comments({ organization: '{{repository.organization}}', project: '{{repository.project}}', repository: '{{repository.name}}', pullRequestId: {{pr_number}} })",
+  "get_pr_reviews": "mcp_ado_get_pr_reviews({ organization: '{{repository.organization}}', project: '{{repository.project}}', repository: '{{repository.name}}', pullRequestId: {{pr_number}} })",
+  "add_pr_comment": "mcp_ado_add_pr_comment({ organization: '{{repository.organization}}', project: '{{repository.project}}', repository: '{{repository.name}}', pullRequestId: {{pr_number}}, content: '{{comment}}' })",
+  "merge_pr": "mcp_ado_merge_pull_request({ organization: '{{repository.organization}}', project: '{{repository.project}}', repository: '{{repository.name}}', pullRequestId: {{pr_number}} })",
+  "create_branch": "git checkout -b feature/{{issue_number}}-{{slug}}",
+  "switch_branch": "git checkout {{branch}}",
+  "commit_changes": "git add . && git commit -m '{{message}}'",
+  "push_branch": "git push origin {{branch}}",
+  "list_issues": "mcp_ado_list_work_items({ organization: '{{repository.organization}}', project: '{{repository.project}}', state: 'Active' })",
+  "create_issue": "mcp_ado_create_work_item({ organization: '{{repository.organization}}', project: '{{repository.project}}', workItemType: 'Bug', title: '{{title}}', description: '{{body}}' })",
+  "add_issue_comment": "mcp_ado_add_work_item_comment({ organization: '{{repository.organization}}', project: '{{repository.project}}', workItemId: {{issue_number}}, text: '{{comment}}' })",
+  "assign_issue": "mcp_ado_update_work_item({ organization: '{{repository.organization}}', project: '{{repository.project}}', workItemId: {{issue_number}}, assignedTo: '{{assignee}}' })"
+}

package/dist/registry/providers/github.json

@@ -0,0 +1,19 @@
+{
+  "get_issue": "mcp_github_issue_read({ owner: '{{repository.owner}}', repo: '{{repository.name}}', issue_number: {{issue_number}}, method: 'get' })",
+  "update_issue_status": "mcp_github_issue_write({ owner: '{{repository.owner}}', repo: '{{repository.name}}', issue_number: {{issue_number}}, method: 'update', labels: ['status:in-progress'] })",
+  "create_pr": "mcp_github_create_pull_request({ owner: '{{repository.owner}}', repo: '{{repository.name}}', title: '{{title}}', head: '{{branch}}', base: 'main', body: '{{body}}' })",
+  "get_pr": "mcp_github_pull_request_read({ owner: '{{repository.owner}}', repo: '{{repository.name}}', pullNumber: {{pr_number}}, method: 'get' })",
+  "get_pr_comments": "mcp_github_pull_request_read({ owner: '{{repository.owner}}', repo: '{{repository.name}}', pullNumber: {{pr_number}}, method: 'get_comments' })",
+  "get_pr_review_comments": "mcp_github_pull_request_read({ owner: '{{repository.owner}}', repo: '{{repository.name}}', pullNumber: {{pr_number}}, method: 'get_review_comments' })",
+  "get_pr_reviews": "mcp_github_pull_request_read({ owner: '{{repository.owner}}', repo: '{{repository.name}}', pullNumber: {{pr_number}}, method: 'get_reviews' })",
+  "add_pr_comment": "mcp_github_add_issue_comment({ owner: '{{repository.owner}}', repo: '{{repository.name}}', issue_number: {{pr_number}}, body: '{{comment}}' })",
+  "merge_pr": "mcp_github_merge_pull_request({ owner: '{{repository.owner}}', repo: '{{repository.name}}', pullNumber: {{pr_number}} })",
+  "create_branch": "git checkout -b feature/{{issue_number}}-{{slug}}",
+  "switch_branch": "git checkout {{branch}}",
+  "commit_changes": "git add . && git commit -m '{{message}}'",
+  "push_branch": "git push origin {{branch}}",
+  "list_issues": "mcp_github_list_issues({ owner: '{{repository.owner}}', repo: '{{repository.name}}', state: 'OPEN' })",
+  "create_issue": "mcp_github_issue_write({ owner: '{{repository.owner}}', repo: '{{repository.name}}', method: 'create', title: '{{title}}', body: '{{body}}' })",
+  "add_issue_comment": "mcp_github_add_issue_comment({ owner: '{{repository.owner}}', repo: '{{repository.name}}', issue_number: {{issue_number}}, body: '{{comment}}' })",
+  "assign_issue": "mcp_github_issue_write({ owner: '{{repository.owner}}', repo: '{{repository.name}}', issue_number: {{issue_number}}, method: 'update', assignees: ['{{assignee}}'] })"
+}

package/dist/src/ai-manager/ai-manager.js

@@ -50,11 +50,12 @@ class AICoach {
      * Handle coaching request from agent
      */
     async handleCoachingRequest(args) {
-        // console.log(`🤖 AI Coach: Providing guidance for ${args.workflowType} workflow, phase: ${args.currentPhase}, status: ${args.status}`);
+        console.log(`🤖 AI Coach: Providing guidance for ${args.workflowType} workflow, phase: ${args.currentPhase}, status: ${args.status}`);
         // Validate required parameters
         const requiredParams = ['workflowType', 'currentPhase', 'status'];
         const missingParams = requiredParams.filter(param => !args[param]);
         if (missingParams.length > 0) {
+            console.log(`❌ AI Coach: Missing required parameters: ${missingParams.join(', ')}`);
             throw new Error(`Missing required parameters: ${missingParams.join(', ')}`);
         }
         // Handle missing or empty issue number gracefully
@@ -78,10 +79,12 @@ Example: \`seekCoachingOnNextStep({ workflowType: "${args.workflowType}", issueN
         // Validate workflow type
         const validWorkflowTypes = ['implement', 'spec', 'design', 'test'];
         if (!validWorkflowTypes.includes(args.workflowType)) {
+            console.log(`❌ AI Coach: Invalid workflow type: ${args.workflowType}`);
             throw new Error(`Invalid workflow type: ${args.workflowType}. Valid types: ${validWorkflowTypes.join(', ')}`);
         }
         // Validate phase for workflow type
         const issueType = this.extractIssueType(args.findings, args.evidence);
+        console.log(`🔍 AI Coach: Extracted issue type: ${issueType}`);
         if (!(0, phase_flow_js_1.isPhaseValidForWorkflow)(args.currentPhase, args.workflowType, issueType)) {
             // Special handling for implement workflow to provide better error messages
             if (args.workflowType === 'implement') {
@@ -132,15 +135,19 @@ ${this.getValidPhasesForIssueType(issueType).join(' → ')}
             }
         }
         if (args.status === 'complete') {
+            console.log(`✅ AI Coach: Generating completion message`);
             return await this.generateCompletionMessage(args);
         }
         else if (args.status === 'incomplete') {
+            console.log(`🤝 AI Coach: Generating help message`);
             return await this.generateHelpMessage(args);
         }
         else if (args.status === 'failure') {
+            console.log(`❌ AI Coach: Generating failure message`);
             return await this.generateFailureMessage(args);
         }
         else {
+            console.log(`📖 AI Coach: Getting phase instructions for ${args.currentPhase}`);
             return await this.getPhaseInstructions(args.currentPhase, args.workflowType);
         }
     }

package/dist/src/ai-manager/phase-flow.js

@@ -61,6 +61,25 @@ const TEST_PHASE_FLOW = [
  * @returns Next phase or null if at end of workflow
  */
 function getNextPhase(currentPhase, workflowType, issueType) {
+    // Special handling for address-pr-feedback phase
+    if (currentPhase === 'address-pr-feedback') {
+        // Success path: After addressing feedback, go back to appropriate validation phase
+        if (workflowType === 'implement') {
+            return 'implement-validate';
+        }
+        else if (workflowType === 'spec') {
+            return 'spec-completeness-review';
+        }
+        else if (workflowType === 'design') {
+            return 'design-completeness-review';
+        }
+        else if (workflowType === 'test') {
+            return 'test-validate';
+        }
+        else {
+            throw new Error(`Unknown workflow type: ${workflowType}`);
+        }
+    }
     let flow;
     if (workflowType === 'implement') {
         if (!issueType) {
@@ -121,10 +140,11 @@ function isPhaseValidForWorkflow(phase, workflowType, issueType) {
  * Get the phase to return to when a phase fails
  * @param failedPhase - The phase that failed
  * @param workflowType - Type of workflow
- * @param issueType - Type of issue (only used for implement workflow)
+ * @param issueType - Type of issue (currently unused - failure handling is the same for bug/feature)
  * @returns Phase to return to
  */
-function getPhaseOnFailure(failedPhase, workflowType, issueType) {
+function getPhaseOnFailure(failedPhase, workflowType, issueType // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
     if (workflowType === 'implement') {
         // Implement workflow failure handling
         switch (failedPhase) {
@@ -147,9 +167,11 @@ function getPhaseOnFailure(failedPhase, workflowType, issueType) {
             case 'submit-pr':
                 return 'implement-completeness-review'; // PR submission issues, review completeness
             case 'wait-for-pr-review':
-                // This phase determines where to go based on PR comment analysis
-                // Will be handled by the PR comment analysis logic
-                return 'implement-code'; // Default fallback for PR feedback
+                // PR feedback should go to address-pr-feedback phase
+                return 'address-pr-feedback';
+            case 'address-pr-feedback':
+                // If addressing PR feedback fails, retry the same phase
+                return 'address-pr-feedback';
             default:
                 return 'implement-code'; // Default fallback
         }
@@ -164,7 +186,9 @@ function getPhaseOnFailure(failedPhase, workflowType, issueType) {
             case 'submit-pr':
                 return 'spec-completeness-review';
             case 'wait-for-pr-review':
-                return 'spec-spec'; // PR feedback usually means spec changes needed
+                return 'address-pr-feedback'; // PR feedback goes to address phase
+            case 'address-pr-feedback':
+                return 'address-pr-feedback'; // Retry addressing feedback
             default:
                 return 'spec-spec';
         }
@@ -179,7 +203,9 @@ function getPhaseOnFailure(failedPhase, workflowType, issueType) {
             case 'submit-pr':
                 return 'design-completeness-review';
             case 'wait-for-pr-review':
-                return 'design-design'; // PR feedback usually means design changes needed
+                return 'address-pr-feedback'; // PR feedback goes to address phase
+            case 'address-pr-feedback':
+                return 'address-pr-feedback'; // Retry addressing feedback
             default:
                 return 'design-design';
         }
@@ -194,7 +220,9 @@ function getPhaseOnFailure(failedPhase, workflowType, issueType) {
             case 'submit-pr':
                 return 'test-validate';
             case 'wait-for-pr-review':
-                return 'test-test'; // PR feedback usually means test changes needed
+                return 'address-pr-feedback'; // PR feedback goes to address phase
+            case 'address-pr-feedback':
+                return 'address-pr-feedback'; // Retry addressing feedback
             default:
                 return 'test-test';
         }

package/dist/src/cli/commands/init-project.js

@@ -46,10 +46,11 @@ const runInitProject = async () => {
                 ...types_1.DEFAULT_FRAIM_CONFIG.project,
                 name: remoteInfo.repo || path_1.default.basename(projectRoot)
             },
-            git: {
-                ...types_1.DEFAULT_FRAIM_CONFIG.git,
-                repoOwner: remoteInfo.owner || types_1.DEFAULT_FRAIM_CONFIG.git.repoOwner,
-                repoName: remoteInfo.repo || path_1.default.basename(projectRoot)
+            repository: {
+                provider: 'github',
+                owner: remoteInfo.owner || 'your-username',
+                name: remoteInfo.repo || path_1.default.basename(projectRoot),
+                defaultBranch: 'main'
             }
         };
         fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));

package/dist/src/cli/commands/init.js

@@ -10,7 +10,6 @@ const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const first_run_1 = require("../setup/first-run");
 const sync_1 = require("./sync");
-const types_1 = require("../../fraim/types");
 const git_utils_1 = require("../../utils/git-utils");
 const version_utils_1 = require("../../utils/version-utils");
 const script_sync_utils_1 = require("../../utils/script-sync-utils");
@@ -35,16 +34,18 @@ const runInit = async () => {
             process.exit(1);
         }
         const config = {
-            ...types_1.DEFAULT_FRAIM_CONFIG,
             version: (0, version_utils_1.getFraimVersion)(),
             project: {
-                ...types_1.DEFAULT_FRAIM_CONFIG.project,
                 name: remoteInfo.repo
             },
-            git: {
-                ...types_1.DEFAULT_FRAIM_CONFIG.git,
-                repoOwner: remoteInfo.owner || types_1.DEFAULT_FRAIM_CONFIG.git.repoOwner,
-                repoName: remoteInfo.repo
+            repository: {
+                provider: 'github',
+                owner: remoteInfo.owner || 'your-username',
+                name: remoteInfo.repo,
+                defaultBranch: remoteInfo.defaultBranch || 'main'
+            },
+            customizations: {
+                workflowsPath: '.fraim/workflows'
             }
         };
         fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));