speckit-assistant 0.1.3 → 0.1.4

package/bin/adapters/secondary/agent/ProcessAgentRunner.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProcessAgentRunner = void 0;
-const child_process_1 = require("child_process");
+const ptyLoader_1 = require("../pty/ptyLoader");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const PHASE_COMMANDS = {
@@ -49,43 +49,138 @@ const PHASE_COMMANDS = {
     implementation: '/speckit.implement',
 };
 class ProcessAgentRunner {
+    activeProcesses = new Map();
+    phaseKey(featureName, phase) {
+        return `${featureName || 'global'}-${phase}`;
+    }
+    personaKey(featureName, id) {
+        return `${featureName}-impl-persona-${id}`;
+    }
+    async writeStdin(phase, featureName, text, personaId) {
+        const procKey = personaId && featureName
+            ? this.personaKey(featureName, personaId)
+            : this.phaseKey(featureName, phase);
+        const child = this.activeProcesses.get(procKey);
+        if (child) {
+            // The frontend xterm sends raw keystrokes (arrow keys, Enter as '\r', etc.)
+            // so we forward them verbatim — this is what lets interactive pickers like
+            // the clarify Q&A be navigated, not just line-based answers.
+            child.write(text);
+            return true;
+        }
+        return false;
+    }
+    async resize(phase, featureName, cols, rows, personaId) {
+        const procKey = personaId && featureName
+            ? this.personaKey(featureName, personaId)
+            : this.phaseKey(featureName, phase);
+        const child = this.activeProcesses.get(procKey);
+        if (!child)
+            return false;
+        try {
+            child.resize(cols, rows);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async stop(phase, featureName, personaId) {
+        const procKey = personaId && featureName
+            ? this.personaKey(featureName, personaId)
+            : this.phaseKey(featureName, phase);
+        const child = this.activeProcesses.get(procKey);
+        if (child) {
+            try {
+                child.kill();
+                this.activeProcesses.delete(procKey);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
     async runPhase(workspacePath, phase, featureName, agentConfig, userPrompt, onData) {
         const specArg = phase !== 'constitution' && featureName ? `specs/${featureName}` : null;
         const slashCmd = `${PHASE_COMMANDS[phase]}${specArg ? ` ${specArg}` : ''}`;
         const context = userPrompt?.trim();
         const fullPrompt = context ? `${context}\n\n${slashCmd}` : slashCmd;
+        return this.spawnAgent({
+            workspacePath,
+            procKey: this.phaseKey(featureName, phase),
+            doneTag: phase,
+            agentConfig,
+            fullPrompt,
+            onData,
+        });
+    }
+    async runPersona(workspacePath, featureName, persona, agentConfig, onData) {
+        // Personas always operate on a specific feature's artifacts.
+        const fullPrompt = `${persona.command} specs/${featureName}`;
+        return this.spawnAgent({
+            workspacePath,
+            procKey: this.personaKey(featureName, persona.id),
+            doneTag: `persona:${persona.id}`,
+            agentConfig,
+            fullPrompt,
+            onData,
+            persona,
+        });
+    }
+    // Shared spawn path for both phase and persona runs: spawns the agent CLI
+    // under a PTY (so interactive CLIs detect a TTY), streams output, and resolves
+    // with the exit code.
+    spawnAgent(opts) {
+        const { workspacePath, procKey, doneTag, agentConfig, fullPrompt, onData } = opts;
         const { cmd, args, stdin } = this.buildSpawnArgs(agentConfig, fullPrompt);
-        const isWin = process.platform === 'win32';
         return new Promise((resolve) => {
             onData?.(`Running: ${cmd} ${args.join(' ')}\n\n`);
-            const child = isWin
-                ? (0, child_process_1.spawn)(cmd, args, {
-                    cwd: workspacePath,
-                    shell: true,
-                    stdio: ['pipe', 'pipe', 'pipe']
-                })
-                : (() => {
-                    const shell = process.env.SHELL || '/bin/sh';
-                    const escapedArgs = [cmd, ...args].map(arg => `'${arg.replace(/'/g, "'\\''")}'`).join(' ');
-                    return (0, child_process_1.spawn)(shell, ['-l', '-c', escapedArgs], {
-                        cwd: workspacePath,
-                        stdio: ['pipe', 'pipe', 'pipe']
-                    });
-                })();
-            if (stdin !== undefined && child.stdin) {
-                child.stdin.write(stdin);
-                child.stdin.end();
-            }
-            child.stdout.on('data', (data) => {
-                const text = data.toString();
-                onData?.(text);
+            // Spawn the agent under a real pseudo-terminal. This is what makes
+            // interactive CLIs (e.g. the clarify Q&A) detect a TTY via isatty() and
+            // actually prompt the user instead of running single-shot. We still go
+            // through a login shell so PATH/aliases resolve the agent binary the same
+            // way they would in the user's own terminal.
+            const isWin = process.platform === 'win32';
+            const ptyFile = isWin
+                ? (process.env.COMSPEC || 'cmd.exe')
+                : (process.env.SHELL || '/bin/bash');
+            const ptyArgs = isWin
+                ? ['/c', [cmd, ...args].join(' ')]
+                : ['-l', '-c', [cmd, ...args].map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ')];
+            const child = (0, ptyLoader_1.loadPty)().spawn(ptyFile, ptyArgs, {
+                name: 'xterm-256color',
+                cols: 120,
+                rows: 30,
+                cwd: workspacePath,
+                env: {
+                    ...process.env,
+                    TERM: 'xterm-256color',
+                    ...(opts.persona ? {
+                        SPECKIT_PERSONA_ID: opts.persona.id || '',
+                        SPECKIT_PERSONA_LABEL: opts.persona.label || '',
+                        SPECKIT_PERSONA_MODEL: opts.persona.model || '',
+                        SPECKIT_PERSONA_SYSTEM_PROMPT: opts.persona.systemPrompt || '',
+                        SPECKIT_PERSONA_CAPABILITIES: Array.isArray(opts.persona.capabilities) ? opts.persona.capabilities.join(',') : '',
+                        SPECKIT_PERSONA_TOOLS: Array.isArray(opts.persona.tools) ? opts.persona.tools.join(',') : '',
+                    } : {})
+                },
             });
-            child.stderr.on('data', (data) => {
-                const text = data.toString();
-                onData?.(text);
+            this.activeProcesses.set(procKey, child);
+            // For agents that receive their prompt over stdin, feed it now and send
+            // EOF (Ctrl-D) so the single-shot CLI starts processing. Agents that take
+            // the prompt as an argument keep the channel open so the user can answer
+            // interactive prompts (e.g. clarify) through writeStdin().
+            if (stdin !== undefined) {
+                child.write(stdin);
+                child.write('\x04');
+            }
+            child.onData((data) => {
+                onData?.(data);
             });
-            child.on('close', (code) => {
-                const exitCode = code === null ? -1 : code;
+            child.onExit(({ exitCode }) => {
+                this.activeProcesses.delete(procKey);
                 onData?.(`\nProcess exited with code ${exitCode}\n`);
                 // Write the phase done file so local watch logs it
                 try {
@@ -93,17 +188,13 @@ class ProcessAgentRunner {
                     if (!fs.existsSync(runtimeDir)) {
                         fs.mkdirSync(runtimeDir, { recursive: true });
                     }
-                    fs.writeFileSync(path.join(runtimeDir, 'phase-done.txt'), `${phase}:${exitCode}`, 'utf-8');
+                    fs.writeFileSync(path.join(runtimeDir, 'phase-done.txt'), `${doneTag}:${exitCode}`, 'utf-8');
                 }
                 catch {
                     // ignore
                 }
                 resolve(exitCode);
             });
-            child.on('error', (err) => {
-                onData?.(`\nFailed to start process: ${err.message}\n`);
-                resolve(-1);
-            });
         });
     }
     buildSpawnArgs(config, prompt) {

package/bin/adapters/secondary/fs/FSWorkspaceRepository.js

@@ -61,7 +61,12 @@ class FSWorkspaceRepository {
         else {
             state.constitutionPhase.filePath = null;
             state.constitutionPhase.content = null;
-            state.constitutionPhase.status = 'idle';
+            // Don't clobber explicit user/runtime states when no file is on disk:
+            // 'running' (agent still generating) and 'approved' (a stored user decision,
+            // e.g. advanced via Kanban drag) must survive reconciliation.
+            if (!this.isUserState(state.constitutionPhase.status)) {
+                state.constitutionPhase.status = 'idle';
+            }
         }
         // 2. Reconcile Features in specs/
         const specsDir = path.join(workspacePath, 'specs');
@@ -100,7 +105,9 @@ class FSWorkspaceRepository {
                     else {
                         ps.filePath = null;
                         ps.content = null;
-                        ps.status = 'idle';
+                        if (!this.isUserState(ps.status)) {
+                            ps.status = 'idle';
+                        }
                     }
                 }
                 // Reconcile clarification (clarification.md or clarify.md)
@@ -118,7 +125,9 @@ class FSWorkspaceRepository {
                 else {
                     clarifyPhase.filePath = null;
                     clarifyPhase.content = null;
-                    clarifyPhase.status = 'idle';
+                    if (!this.isUserState(clarifyPhase.status)) {
+                        clarifyPhase.status = 'idle';
+                    }
                 }
                 // Implementation phase doesn't have its own file, but we can resolve its status.
                 // If specs/[feature]/tasks.md exists, and all checkboxes are checked, it could be complete.
@@ -127,6 +136,24 @@ class FSWorkspaceRepository {
                 // Make sure its filePath is null (since there is no implementation.md file)
                 implPhase.filePath = null;
                 implPhase.content = null;
+                // Reconcile review-gate personas against their report files. Statuses
+                // saved by the gate are kept; this is a safety net that also reflects a
+                // report written/edited out of band. Never downgrade a 'running' persona.
+                if (implPhase.personas) {
+                    for (const persona of implPhase.personas) {
+                        const reportFp = path.join(specsDir, feature.name, 'reviews', `${persona.id}.md`);
+                        if (fs.existsSync(reportFp)) {
+                            persona.reportPath = path.join('specs', feature.name, 'reviews', `${persona.id}.md`);
+                            if (persona.status !== 'running') {
+                                const verdict = fs.readFileSync(reportFp, 'utf-8').toUpperCase();
+                                if (/VERDICT:\s*FAIL/.test(verdict))
+                                    persona.status = 'failed';
+                                else if (/VERDICT:\s*PASS/.test(verdict))
+                                    persona.status = 'passed';
+                            }
+                        }
+                    }
+                }
             }
         }
         else {
@@ -156,7 +183,9 @@ class FSWorkspaceRepository {
                 phases: f.phases.map(p => ({
                     phase: p.phase,
                     status: p.status,
-                    stale: p.stale
+                    stale: p.stale,
+                    // Persist the implementation review-gate persona statuses.
+                    ...(p.personas ? { personas: p.personas.map(ps => ({ id: ps.id, status: ps.status })) } : {})
                 }))
             })),
             activeFeatureName: state.activeFeatureName
@@ -245,6 +274,9 @@ class FSWorkspaceRepository {
             phases: FEATURE_PHASES.map(p => this.makePhaseState(p))
         };
     }
+    isUserState(status) {
+        return status === 'running' || status === 'approved';
+    }
     loadStateFile(workspacePath) {
         const statePath = path.join(workspacePath, '.specify', '.runtime', 'workflow-state.json');
         if (!fs.existsSync(statePath)) {
@@ -267,7 +299,10 @@ class FSWorkspaceRepository {
                             status: savedPhase?.status || 'idle',
                             stale: savedPhase?.stale || false,
                             filePath: null,
-                            content: null
+                            content: null,
+                            ...(Array.isArray(savedPhase?.personas)
+                                ? { personas: savedPhase.personas.map((ps) => ({ id: ps.id, status: ps.status || 'idle' })) }
+                                : {})
                         };
                     })
                 }));

package/bin/adapters/secondary/pty/ptyLoader.js

@@ -0,0 +1,128 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPty = loadPty;
+exports._clearPtyCacheForTesting = _clearPtyCacheForTesting;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+let cached = null;
+class PureJsPtyLike {
+    child;
+    constructor(child) {
+        this.child = child;
+    }
+    write(data) {
+        this.child.stdin?.write(data);
+    }
+    resize(cols, rows) {
+        // No-op for standard child_process pipes
+    }
+    kill(signal) {
+        this.child.kill(signal);
+    }
+    onData(cb) {
+        this.child.stdout?.on('data', (chunk) => cb(chunk.toString()));
+        this.child.stderr?.on('data', (chunk) => cb(chunk.toString()));
+    }
+    onExit(cb) {
+        this.child.on('exit', (code, signal) => {
+            cb({ exitCode: code ?? 0, signal: signal ? 1 : undefined });
+        });
+    }
+}
+const pureJsPtyModule = {
+    spawn(file, args, options) {
+        const cp = (0, child_process_1.spawn)(file, args, {
+            cwd: options.cwd,
+            env: options.env,
+        });
+        return new PureJsPtyLike(cp);
+    }
+};
+/**
+ * Loads node-pty defensively.
+ *
+ * node-pty relies on a native `spawn-helper` binary (on POSIX) that must be
+ * executable. Some package managers / extraction paths drop the exec bit when
+ * unpacking the prebuilt binaries, which makes pty.spawn fail with
+ * "posix_spawnp failed". We restore the exec bit before first use so the
+ * workspace shell and interactive agent phases work regardless of how the
+ * dependency was installed.
+ */
+function loadPty() {
+    if (cached)
+        return cached;
+    if (process.env.SPECKIT_TEST_FORCE_FALLBACK === 'true') {
+        cached = pureJsPtyModule;
+        return pureJsPtyModule;
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pty = require('node-pty');
+        if (process.platform !== 'win32') {
+            try {
+                const ptyDir = path.dirname(require.resolve('node-pty/package.json'));
+                const prebuilds = path.join(ptyDir, 'prebuilds');
+                if (fs.existsSync(prebuilds)) {
+                    for (const entry of fs.readdirSync(prebuilds)) {
+                        const helper = path.join(prebuilds, entry, 'spawn-helper');
+                        if (fs.existsSync(helper)) {
+                            try {
+                                fs.chmodSync(helper, 0o755);
+                            }
+                            catch {
+                                // best effort
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // best effort — if anything fails we still return the module
+            }
+        }
+        cached = pty;
+        return pty;
+    }
+    catch (err) {
+        console.warn('node-pty failed to load, falling back to pure child_process pty emulation.');
+        cached = pureJsPtyModule;
+        return pureJsPtyModule;
+    }
+}
+function _clearPtyCacheForTesting() {
+    cached = null;
+}

package/bin/app/api/git/route.js

@@ -0,0 +1,156 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const server_1 = require("next/server");
+const utils_1 = require("../../../adapters/primary/api/utils");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function runGit(cmd, cwd) {
+    try {
+        return (0, child_process_1.execSync)(cmd, { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function getRefBranch(cwd) {
+    const output = runGit('git branch --format="%(refname:short)"', cwd);
+    const branches = output.split('\n').map(b => b.trim());
+    if (branches.includes('main'))
+        return 'main';
+    if (branches.includes('master'))
+        return 'master';
+    return 'HEAD';
+}
+async function GET(req) {
+    try {
+        const { searchParams } = new URL(req.url);
+        const action = searchParams.get('action');
+        const filePath = searchParams.get('file');
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        // Check if git is initialized
+        if (!fs.existsSync(path.join(workspacePath, '.git'))) {
+            return server_1.NextResponse.json({
+                files: [],
+                log: [],
+                error: 'Git repository not found in workspace.'
+            });
+        }
+        const ref = getRefBranch(workspacePath);
+        if (action === 'diff' && filePath) {
+            const absPath = path.resolve(workspacePath, filePath);
+            // Safety check: ensure file is inside workspace
+            const normWorkspace = path.normalize(workspacePath).replace(/\\/g, '/').toLowerCase();
+            const normFile = path.normalize(absPath).replace(/\\/g, '/').toLowerCase();
+            if (!normFile.startsWith(normWorkspace)) {
+                return server_1.NextResponse.json({ error: 'Access denied' }, { status: 403 });
+            }
+            // Check if file is untracked
+            const statusOutput = runGit(`git status --porcelain "${filePath}"`, workspacePath);
+            const isUntracked = statusOutput.startsWith('??');
+            if (isUntracked && fs.existsSync(absPath)) {
+                // Return file contents prefixed with + to simulate unified diff for new file
+                const content = fs.readFileSync(absPath, 'utf-8');
+                const diffLines = content.split('\n').map(line => `+${line}`).join('\n');
+                return server_1.NextResponse.json({ diff: diffLines });
+            }
+            const diffOutput = runGit(`git diff ${ref} -- "${filePath}"`, workspacePath);
+            return server_1.NextResponse.json({ diff: diffOutput || 'No modifications found.' });
+        }
+        if (action === 'status') {
+            // 1. Get modified files with stats
+            const numstatOutput = runGit(`git diff ${ref} --numstat`, workspacePath);
+            const filesMap = {};
+            if (numstatOutput) {
+                numstatOutput.split('\n').forEach(line => {
+                    const parts = line.split('\t');
+                    if (parts.length >= 3) {
+                        const additions = parseInt(parts[0], 10) || 0;
+                        const deletions = parseInt(parts[1], 10) || 0;
+                        const relPath = parts[2].trim();
+                        const ext = path.extname(relPath).toLowerCase();
+                        const isTest = relPath.endsWith('.test.ts') || relPath.endsWith('.test.js') || relPath.endsWith('.spec.ts') || relPath.endsWith('.spec.js');
+                        const type = isTest ? 'test'
+                            : (ext === '.ts' || ext === '.js' || ext === '.tsx' || ext === '.jsx' ? 'code' : 'doc');
+                        filesMap[relPath] = { path: relPath, additions, deletions, type };
+                    }
+                });
+            }
+            // 2. Get untracked files and append them
+            const statusOutput = runGit('git status --porcelain', workspacePath);
+            if (statusOutput) {
+                statusOutput.split('\n').forEach(line => {
+                    if (line.startsWith('??')) {
+                        const relPath = line.substring(3).trim();
+                        if (!filesMap[relPath]) {
+                            // Estimate lines as additions
+                            let additions = 0;
+                            const absPath = path.join(workspacePath, relPath);
+                            try {
+                                if (fs.existsSync(absPath) && fs.statSync(absPath).isFile()) {
+                                    additions = fs.readFileSync(absPath, 'utf-8').split('\n').length;
+                                }
+                            }
+                            catch {
+                                // ignore
+                            }
+                            const ext = path.extname(relPath).toLowerCase();
+                            const isTest = relPath.endsWith('.test.ts') || relPath.endsWith('.test.js') || relPath.endsWith('.spec.ts') || relPath.endsWith('.spec.js');
+                            const type = isTest ? 'test'
+                                : (ext === '.ts' || ext === '.js' || ext === '.tsx' || ext === '.jsx' ? 'code' : 'doc');
+                            filesMap[relPath] = { path: relPath, additions, deletions: 0, type };
+                        }
+                    }
+                });
+            }
+            const files = Object.values(filesMap);
+            // 3. Get Git Log
+            const logOutput = runGit('git log -n 10 --pretty=format:"%h|%s|%an|%ar"', workspacePath);
+            const log = logOutput ? logOutput.split('\n').map(line => {
+                const [hash, message, author, date] = line.split('|');
+                return { hash, message, author, date };
+            }) : [];
+            // 4. Get active branch name
+            const branch = runGit('git rev-parse --abbrev-ref HEAD', workspacePath) || 'HEAD';
+            return server_1.NextResponse.json({ files, log, branch });
+        }
+        return server_1.NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}

package/bin/app/api/personas/route.js

@@ -0,0 +1,76 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+exports.POST = POST;
+const server_1 = require("next/server");
+const utils_1 = require("../../../adapters/primary/api/utils");
+const personas_1 = require("../../../domain/models/personas");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function GET() {
+    try {
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        const configPath = path.join(workspacePath, '.specify', 'personas-config.json');
+        if (!fs.existsSync(configPath)) {
+            return server_1.NextResponse.json(personas_1.DEFAULT_PERSONAS);
+        }
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        return server_1.NextResponse.json(parsed);
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}
+async function POST(req) {
+    try {
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        const body = await req.json();
+        if (!Array.isArray(body)) {
+            return server_1.NextResponse.json({ error: 'Body must be an array of persona configs' }, { status: 400 });
+        }
+        const configDir = path.join(workspacePath, '.specify');
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        const configPath = path.join(configDir, 'personas-config.json');
+        fs.writeFileSync(configPath, JSON.stringify(body, null, 2), 'utf-8');
+        return server_1.NextResponse.json({ success: true, personas: body });
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}