fraim 2.0.129 → 2.0.130

package/dist/src/core/fraim-config-schema.generated.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * Generated from src/core/types.ts.
+ * This file exists so runtime validation and config token checks read the same persisted config shape the agent sees.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_FRAIM_CONFIG_PATHS = exports.FRAIM_CONFIG_SCHEMA = void 0;
+exports.FRAIM_CONFIG_SCHEMA = {
+    "kind": "object",
+    "properties": {
+        "version": {
+            "kind": "string",
+            "required": true
+        },
+        "project": {
+            "kind": "object",
+            "properties": {
+                "name": {
+                    "kind": "string",
+                    "required": true
+                },
+                "industry": {
+                    "kind": "string"
+                }
+            },
+            "required": true
+        },
+        "repository": {
+            "kind": "object",
+            "properties": {
+                "provider": {
+                    "kind": "enum",
+                    "values": [
+                        "github",
+                        "ado",
+                        "gitlab"
+                    ]
+                },
+                "owner": {
+                    "kind": "string"
+                },
+                "name": {
+                    "kind": "string"
+                },
+                "organization": {
+                    "kind": "string"
+                },
+                "project": {
+                    "kind": "string"
+                },
+                "namespace": {
+                    "kind": "string"
+                },
+                "projectPath": {
+                    "kind": "string"
+                },
+                "url": {
+                    "kind": "string"
+                },
+                "defaultBranch": {
+                    "kind": "string"
+                }
+            }
+        },
+        "issueTracking": {
+            "kind": "object",
+            "properties": {
+                "provider": {
+                    "kind": "enum",
+                    "values": [
+                        "jira",
+                        "github",
+                        "ado",
+                        "linear",
+                        "gitlab"
+                    ],
+                    "required": true
+                },
+                "owner": {
+                    "kind": "string"
+                },
+                "name": {
+                    "kind": "string"
+                },
+                "organization": {
+                    "kind": "string"
+                },
+                "project": {
+                    "kind": "string"
+                },
+                "namespace": {
+                    "kind": "string"
+                },
+                "projectPath": {
+                    "kind": "string"
+                },
+                "baseUrl": {
+                    "kind": "string"
+                },
+                "projectKey": {
+                    "kind": "string"
+                },
+                "branchPattern": {
+                    "kind": "string"
+                },
+                "apiToken": {
+                    "kind": "string"
+                },
+                "email": {
+                    "kind": "string"
+                },
+                "apiKey": {
+                    "kind": "string"
+                },
+                "teamId": {
+                    "kind": "string"
+                }
+            }
+        },
+        "mode": {
+            "kind": "enum",
+            "values": [
+                "conversational",
+                "integrated",
+                "split"
+            ]
+        },
+        "customizations": {
+            "kind": "object",
+            "properties": {
+                "architectureDoc": {
+                    "kind": "string"
+                },
+                "designSystem": {
+                    "kind": "object",
+                    "properties": {
+                        "path": {
+                            "kind": "string"
+                        },
+                        "brand": {
+                            "kind": "string"
+                        }
+                    }
+                },
+                "validation": {
+                    "kind": "object",
+                    "properties": {
+                        "buildCommand": {
+                            "kind": "string"
+                        },
+                        "testSuiteCommand": {
+                            "kind": "string"
+                        },
+                        "smokeTestCommand": {
+                            "kind": "string"
+                        }
+                    }
+                },
+                "postCleanupHook": {
+                    "kind": "string"
+                }
+            }
+        },
+        "remoteUrl": {
+            "kind": "string"
+        },
+        "apiKey": {
+            "kind": "string"
+        },
+        "competitors": {
+            "kind": "record",
+            "value": {
+                "kind": "string"
+            }
+        },
+        "compliance": {
+            "kind": "object",
+            "properties": {
+                "regulations": {
+                    "kind": "array",
+                    "element": {
+                        "kind": "string"
+                    }
+                },
+                "compliance_specifications": {
+                    "kind": "record",
+                    "value": {
+                        "kind": "string"
+                    }
+                }
+            }
+        },
+        "learning": {
+            "kind": "object",
+            "properties": {
+                "lastSynthesisDate": {
+                    "kind": "string"
+                },
+                "scoreThreshold": {
+                    "kind": "number"
+                }
+            }
+        },
+        "customer-communication": {
+            "kind": "object",
+            "properties": {
+                "productName": {
+                    "kind": "string",
+                    "required": true
+                },
+                "productUrl": {
+                    "kind": "string",
+                    "required": true
+                },
+                "senderDisplayName": {
+                    "kind": "string",
+                    "required": true
+                },
+                "senderEmail": {
+                    "kind": "string",
+                    "required": true
+                },
+                "senderReplyTo": {
+                    "kind": "string"
+                },
+                "newsletterAudienceProvider": {
+                    "kind": "string"
+                },
+                "deliveryProvider": {
+                    "kind": "string",
+                    "required": true
+                }
+            }
+        }
+    },
+    "required": true
+};
+exports.SUPPORTED_FRAIM_CONFIG_PATHS = [
+    "version",
+    "project",
+    "project.name",
+    "project.industry",
+    "repository",
+    "repository.provider",
+    "repository.owner",
+    "repository.name",
+    "repository.organization",
+    "repository.project",
+    "repository.namespace",
+    "repository.projectPath",
+    "repository.url",
+    "repository.defaultBranch",
+    "issueTracking",
+    "issueTracking.provider",
+    "issueTracking.owner",
+    "issueTracking.name",
+    "issueTracking.organization",
+    "issueTracking.project",
+    "issueTracking.namespace",
+    "issueTracking.projectPath",
+    "issueTracking.baseUrl",
+    "issueTracking.projectKey",
+    "issueTracking.branchPattern",
+    "issueTracking.apiToken",
+    "issueTracking.email",
+    "issueTracking.apiKey",
+    "issueTracking.teamId",
+    "mode",
+    "customizations",
+    "customizations.architectureDoc",
+    "customizations.designSystem",
+    "customizations.designSystem.path",
+    "customizations.designSystem.brand",
+    "customizations.validation",
+    "customizations.validation.buildCommand",
+    "customizations.validation.testSuiteCommand",
+    "customizations.validation.smokeTestCommand",
+    "customizations.postCleanupHook",
+    "remoteUrl",
+    "apiKey",
+    "competitors",
+    "compliance",
+    "compliance.regulations",
+    "compliance.compliance_specifications",
+    "learning",
+    "learning.lastSynthesisDate",
+    "learning.scoreThreshold",
+    "customer-communication",
+    "customer-communication.productName",
+    "customer-communication.productUrl",
+    "customer-communication.senderDisplayName",
+    "customer-communication.senderEmail",
+    "customer-communication.senderReplyTo",
+    "customer-communication.newsletterAudienceProvider",
+    "customer-communication.deliveryProvider"
+];

package/dist/src/core/utils/setup-preferences.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSetupHandoffChoice = writeSetupHandoffChoice;
+exports.readSetupHandoffChoice = readSetupHandoffChoice;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("./project-fraim-paths");
+const PREFS_FILE = 'preferences.json';
+function getPrefsPath() {
+    return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), PREFS_FILE);
+}
+function writeSetupHandoffChoice(choice) {
+    const dir = (0, project_fraim_paths_1.getUserFraimDirPath)();
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    const filePath = getPrefsPath();
+    let existing = {};
+    try {
+        existing = JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        // file doesn't exist or is invalid JSON — start fresh
+    }
+    existing.setupHandoffChoice = choice;
+    fs_1.default.writeFileSync(filePath, JSON.stringify(existing, null, 2));
+}
+function readSetupHandoffChoice() {
+    try {
+        const raw = fs_1.default.readFileSync(getPrefsPath(), 'utf8');
+        const data = JSON.parse(raw);
+        if (data.setupHandoffChoice === 'ide' || data.setupHandoffChoice === 'hub') {
+            return data.setupHandoffChoice;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/first-run/server.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,6 +42,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const session_service_1 = require("./session-service");
+const setup_preferences_1 = require("../core/utils/setup-preferences");
 function resolveFirstRunPublicDir() {
     const candidates = [
         path_1.default.resolve(process.cwd(), 'public/first-run'),
@@ -29,7 +63,7 @@ function resolveFirstRunPublicDir() {
  * Implementation notes:
  * - Async (`spawn`, not `spawnSync`). The folder dialog blocks until the
  *   user dismisses it, which can be many seconds. With `spawnSync` the
- *   entire Node event loop freezes during that time — every other HTTP
+ *   entire Node event loop freezes during that time - every other HTTP
  *   request to the FRE server gets `ERR_ABORTED`, and the FRE looks dead.
  * - Windows: PowerShell needs `-STA` (Single-Threaded Apartment) for
  *   `System.Windows.Forms.FolderBrowserDialog` to work. We also create a
@@ -39,6 +73,7 @@ function resolveFirstRunPublicDir() {
  *   broken).
  */
 function pickProjectPath() {
+    // Return contract: Promise<string | null>
     if (process.platform === 'win32') {
         const script = [
             'Add-Type -AssemblyName System.Windows.Forms',
@@ -171,7 +206,7 @@ class FirstRunServer {
         this.app.post('/api/first-run/finish', (_req, res) => {
             // Note: /finish writes the next-prompt artifact but does NOT trigger
             // process shutdown. In v1 the Hub server is started in-process by
-            // /open-hub — if we resolved the finishPromise here, runFirstRun
+            // /open-hub - if we resolved the finishPromise here, runFirstRun
             // would call server.stop() and the parent process would exit,
             // taking the just-started Hub down with it. The Hub handoff has
             // to keep the parent alive. The CLI exits when the user Ctrl+Cs
@@ -179,7 +214,27 @@ class FirstRunServer {
             const result = this.sessionService.finish();
             return res.json(result);
         });
-        // Hub-launch helper — starts an AiHubServer for the chosen project and
+        this.app.get('/api/first-run/ide-commands', async (_req, res) => {
+            try {
+                const { detectInstalledIDEs } = await Promise.resolve().then(() => __importStar(require('../cli/setup/ide-detector')));
+                const { describeOnboardingInvocationSurfaces } = await Promise.resolve().then(() => __importStar(require('../cli/setup/ide-global-integration')));
+                const configuredIDEs = detectInstalledIDEs();
+                const commands = describeOnboardingInvocationSurfaces(configuredIDEs);
+                return res.json({ commands });
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not load IDE commands.' });
+            }
+        });
+        this.app.post('/api/first-run/set-preference', (req, res) => {
+            const { choice } = req.body || {};
+            if (choice !== 'ide' && choice !== 'hub') {
+                return res.status(400).json({ error: 'choice must be "ide" or "hub"' });
+            }
+            (0, setup_preferences_1.writeSetupHandoffChoice)(choice);
+            return res.json({ ok: true });
+        });
+        // Hub-launch helper - starts an AiHubServer for the chosen project and
         // opens the user's browser. v2 (#355) replaces the in-process spawn with
         // a durable launcher binary that survives independently.
         this.app.post('/api/first-run/open-hub', async (_req, res) => {
@@ -187,7 +242,7 @@ class FirstRunServer {
                 const result = await this.sessionService.openHub();
                 // Write the next-prompt artifact as a side effect of opening the
                 // Hub so the client doesn't need a separate /finish call. We
-                // intentionally do NOT resolve the finishPromise — see /finish
+                // intentionally do NOT resolve the finishPromise - see /finish
                 // handler comment above.
                 if (result.ok) {
                     this.sessionService.finish();