maskweaver 0.9.9 → 0.10.1

package/dist/weave/stages/intake-ambiguity.js

@@ -0,0 +1,200 @@
+export const AMBIGUITY_THRESHOLD = 0.20;
+export const GHERKIN_READINESS_THRESHOLD = 0.30;
+const GOAL_CLARITY_WEIGHT = 0.40;
+const CONSTRAINT_CLARITY_WEIGHT = 0.30;
+const SUCCESS_CRITERIA_CLARITY_WEIGHT = 0.30;
+const BROWNFIELD_CONTEXT_WEIGHT = 0.15;
+const BROWNFIELD_GOAL_WEIGHT = 0.35;
+const BROWNFIELD_CONSTRAINT_WEIGHT = 0.25;
+const BROWNFIELD_CRITERIA_WEIGHT = 0.25;
+const MILESTONE_DEFINITIONS = [
+    { maxScore: 1.0, label: 'initial', description: '핵심 요구사항만 파악됨. 제약조건과 성공 기준이 큰 공백.' },
+    { maxScore: 0.40, label: 'progress', description: '대부분 요구사항 파악. 일부 세부사항과 경계 조건 누락.' },
+    { maxScore: 0.30, label: 'refined', description: '성공 기준 일부 정의됨. 경계 조건과 비기능 요구사항 보강 필요.' },
+    { maxScore: AMBIGUITY_THRESHOLD, label: 'ready', description: '모든 기준이 구체적이고 테스트 가능. Seed 생성 준비 완료.' },
+];
+function getMilestone(score) {
+    for (const m of MILESTONE_DEFINITIONS) {
+        if (score <= m.maxScore)
+            return { label: m.label, description: m.description };
+    }
+    return { label: 'initial', description: MILESTONE_DEFINITIONS[0].description };
+}
+function getNextMilestone(score) {
+    for (let i = MILESTONE_DEFINITIONS.length - 1; i >= 0; i--) {
+        const m = MILESTONE_DEFINITIONS[i];
+        if (score > m.maxScore) {
+            return { threshold: m.maxScore, label: m.label, description: m.description };
+        }
+    }
+    return undefined;
+}
+function buildJustification(category, score) {
+    const pct = (score * 100).toFixed(0);
+    switch (category) {
+        case 'goal':
+            if (score >= 0.70)
+                return `목표가 명확하고 Gherkin 시나리오로 변환 가능 (${pct}%)`;
+            if (score >= 0.40)
+                return `특징이 식별되었으나 세부사항 부족 (${pct}%)`;
+            return `목표 정의가 불충분. 더 많은 질문 필요 (${pct}%)`;
+        case 'constraint':
+            if (score >= 0.60)
+                return `제약조건이 잘 정의됨 (${pct}%)`;
+            if (score >= 0.30)
+                return `기술 스택은 파악되었으나 경계 조건 정의 필요 (${pct}%)`;
+            return `제약조건 정의가 필요함 (${pct}%)`;
+        case 'criteria':
+            if (score >= 0.70)
+                return `성공 기준이 Gherkin 시나리오로 충분히 정의됨 (${pct}%)`;
+            if (score >= 0.30)
+                return `일부 인수 조건 존재하나 보강 필요 (${pct}%)`;
+            return `인수 조건이 정의되지 않음 (${pct}%)`;
+        case 'context':
+            if (score >= 0.60)
+                return `기존 코드베이스 맥락이 충분히 파악됨 (${pct}%)`;
+            if (score >= 0.30)
+                return `코드베이스 맵은 있으나 세부 이해 부족 (${pct}%)`;
+            return `기존 코드베이스 맥락 파악이 필요함 (${pct}%)`;
+        default:
+            return `Clarity: ${pct}%`;
+    }
+}
+export function scoreAmbiguity(features, techReqs, answers, gherkinScenarios, isBrownfield = false, codebaseMapAvailable = false) {
+    const answerCount = Object.keys(answers).length;
+    const answerDepth = Object.values(answers).reduce((sum, a) => sum + Math.min(a.length / 100, 1.0), 0);
+    const hasFeatures = features.length > 0;
+    const featureDetailScore = hasFeatures
+        ? Math.min(features.reduce((sum, f) => sum + Math.min(f.length / 30, 1.0), 0) / Math.max(features.length, 1), 1.0)
+        : 0;
+    let goalClarityScore = 0.0;
+    if (hasFeatures)
+        goalClarityScore += 0.25;
+    if (featureDetailScore > 0.3)
+        goalClarityScore += 0.15;
+    if (answerCount >= 3)
+        goalClarityScore += 0.15;
+    if (answerDepth >= 1.5)
+        goalClarityScore += 0.15;
+    if (gherkinScenarios && gherkinScenarios.length > 0)
+        goalClarityScore += 0.15;
+    if (answers && (answers['priority'] || Object.keys(answers).some(k => k.includes('우선순위') || k.includes('priority')))) {
+        goalClarityScore += 0.15;
+    }
+    let constraintClarityScore = 0.0;
+    const hasTechStack = (techReqs?.frontend?.length ?? 0) > 0 || (techReqs?.backend?.length ?? 0) > 0;
+    if (hasTechStack)
+        constraintClarityScore += 0.30;
+    if ((techReqs?.database?.length ?? 0) > 0)
+        constraintClarityScore += 0.15;
+    if (answerCount >= 5)
+        constraintClarityScore += 0.15;
+    if (answers && Object.keys(answers).some(k => k.includes('예외') || k.includes('edge') || k.includes('에러'))) {
+        constraintClarityScore += 0.20;
+    }
+    if (answers && Object.keys(answers).some(k => k.includes('제약') || k.includes('constraint') || k.includes('제한'))) {
+        constraintClarityScore += 0.20;
+    }
+    let successCriteriaClarityScore = 0.0;
+    if (gherkinScenarios && gherkinScenarios.length > 0) {
+        const gherkinThenCount = gherkinScenarios.reduce((sum, s) => sum + s.then.length, 0);
+        successCriteriaClarityScore += Math.min(gherkinThenCount * 0.10, 0.30);
+        if (gherkinScenarios.some(s => s.given.length > 0))
+            successCriteriaClarityScore += 0.15;
+        if (gherkinScenarios.some(s => s.when.length > 0))
+            successCriteriaClarityScore += 0.15;
+        if (gherkinScenarios.length >= features.length * 2)
+            successCriteriaClarityScore += 0.15;
+    }
+    if (answerCount >= 7)
+        successCriteriaClarityScore += 0.10;
+    if (answers && Object.keys(answers).some(k => k.includes('성공') || k.includes('측정') || k.includes('metric'))) {
+        successCriteriaClarityScore += 0.15;
+    }
+    let contextClarityScore = 0.0;
+    if (isBrownfield && codebaseMapAvailable) {
+        contextClarityScore += 0.40;
+        if (answers && Object.keys(answers).some(k => k.includes('기존') || k.includes('existing') || k.includes('구조'))) {
+            contextClarityScore += 0.30;
+        }
+        if (answers && Object.keys(answers).some(k => k.includes('마이그레이션') || k.includes('migration') || k.includes('리팩토링') || k.includes('refactor'))) {
+            contextClarityScore += 0.30;
+        }
+    }
+    goalClarityScore = Math.min(1.0, Math.max(0.0, goalClarityScore));
+    constraintClarityScore = Math.min(1.0, Math.max(0.0, constraintClarityScore));
+    successCriteriaClarityScore = Math.min(1.0, Math.max(0.0, successCriteriaClarityScore));
+    contextClarityScore = Math.min(1.0, Math.max(0.0, contextClarityScore));
+    const goalComponent = {
+        name: 'Goal Clarity',
+        clarityScore: goalClarityScore,
+        weight: isBrownfield ? BROWNFIELD_GOAL_WEIGHT : GOAL_CLARITY_WEIGHT,
+        justification: buildJustification('goal', goalClarityScore),
+        thresholds: [
+            { label: 'Features identified', minScore: 0.25, description: '특징이 식별되었는가?' },
+            { label: 'Features detailed', minScore: 0.40, description: '특징에 세부사항이 있는가?' },
+            { label: 'Questions answered', minScore: 0.55, description: '인터뷰 질문에 답했는가?' },
+            { label: 'Gherkin ready', minScore: 0.70, description: 'Gherkin 시나리오로 변환 가능한가?' },
+        ],
+    };
+    const constraintComponent = {
+        name: 'Constraint Clarity',
+        clarityScore: constraintClarityScore,
+        weight: isBrownfield ? BROWNFIELD_CONSTRAINT_WEIGHT : CONSTRAINT_CLARITY_WEIGHT,
+        justification: buildJustification('constraint', constraintClarityScore),
+        thresholds: [
+            { label: 'Tech stack known', minScore: 0.30, description: '기술 스택이 파악되었는가?' },
+            { label: 'Edge cases covered', minScore: 0.50, description: '경계 조건이 다루어졌는가?' },
+            { label: 'All constraints clear', minScore: 0.80, description: '모든 제약조건이 명확한가?' },
+        ],
+    };
+    const criteriaComponent = {
+        name: 'Success Criteria Clarity',
+        clarityScore: successCriteriaClarityScore,
+        weight: isBrownfield ? BROWNFIELD_CRITERIA_WEIGHT : SUCCESS_CRITERIA_CLARITY_WEIGHT,
+        justification: buildJustification('criteria', successCriteriaClarityScore),
+        thresholds: [
+            { label: 'Basic AC exists', minScore: 0.30, description: '기본 인수 조건이 있는가?' },
+            { label: 'Gherkin When/Then', minScore: 0.50, description: 'When/Then 시나리오가 있는가?' },
+            { label: 'Full scenario coverage', minScore: 0.75, description: '충분한 시나리오 커버리지가 있는가?' },
+        ],
+    };
+    const breakdown = {
+        goalClarity: goalComponent,
+        constraintClarity: constraintComponent,
+        successCriteriaClarity: criteriaComponent,
+    };
+    if (isBrownfield && codebaseMapAvailable) {
+        breakdown.contextClarity = {
+            name: 'Context Clarity',
+            clarityScore: contextClarityScore,
+            weight: BROWNFIELD_CONTEXT_WEIGHT,
+            justification: buildJustification('context', contextClarityScore),
+            thresholds: [
+                { label: 'Map available', minScore: 0.30, description: '코드베이스 맵이 있는가?' },
+                { label: 'Patterns understood', minScore: 0.60, description: '기존 패턴이 파악되었는가?' },
+            ],
+        };
+    }
+    const weightedClarity = Object.values(breakdown).reduce((sum, comp) => {
+        if (!comp)
+            return sum;
+        return sum + comp.clarityScore * comp.weight;
+    }, 0);
+    const overallScore = Math.round((1.0 - weightedClarity) * 10000) / 10000;
+    const components = [goalComponent, constraintComponent, criteriaComponent];
+    if (breakdown.contextClarity)
+        components.push(breakdown.contextClarity);
+    const weakest = components.reduce((min, c) => c.clarityScore < min.clarityScore ? c : min, components[0]);
+    const milestone = getMilestone(overallScore);
+    return {
+        overallScore,
+        breakdown,
+        isReadyForSeed: overallScore <= AMBIGUITY_THRESHOLD,
+        readinessForGherkin: overallScore <= GHERKIN_READINESS_THRESHOLD,
+        milestone: milestone.label,
+        milestoneDescription: milestone.description,
+        weakestArea: weakest.name,
+        nextMilestone: getNextMilestone(overallScore),
+    };
+}

package/dist/weave/stages/intake-persistence.d.ts

@@ -0,0 +1,9 @@
+import type { InterviewState } from './intake-types.js';
+export declare function getInterviewDir(basePath: string): string;
+export declare function saveInterviewState(basePath: string, state: InterviewState): void;
+export declare function loadInterviewState(basePath: string, interviewId?: string): InterviewState | null;
+export declare function listInterviewStates(basePath: string): Array<{
+    id: string;
+    status: string;
+    rounds: number;
+}>;

package/dist/weave/stages/intake-persistence.js

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function getInterviewDir(basePath) {
+    const dir = path.join(basePath, '.opencode', 'weave', 'interview');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+function interviewStatePath(basePath, interviewId) {
+    return path.join(getInterviewDir(basePath), `${interviewId}.json`);
+}
+function getLatestInterviewId(basePath) {
+    const dir = getInterviewDir(basePath);
+    try {
+        const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+        if (files.length === 0)
+            return null;
+        return files[files.length - 1].replace('.json', '');
+    }
+    catch {
+        return null;
+    }
+}
+export function saveInterviewState(basePath, state) {
+    const filePath = interviewStatePath(basePath, state.interviewId);
+    state.updatedAt = new Date().toISOString();
+    fs.writeFileSync(filePath, JSON.stringify(state, null, 2), 'utf-8');
+}
+export function loadInterviewState(basePath, interviewId) {
+    const id = interviewId || getLatestInterviewId(basePath);
+    if (!id)
+        return null;
+    const filePath = interviewStatePath(basePath, id);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function listInterviewStates(basePath) {
+    const dir = getInterviewDir(basePath);
+    const results = [];
+    try {
+        for (const file of fs.readdirSync(dir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+                const state = JSON.parse(content);
+                results.push({
+                    id: state.interviewId,
+                    status: state.status,
+                    rounds: state.rounds.length,
+                });
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return results;
+}

package/dist/weave/stages/intake-questions.d.ts

@@ -0,0 +1,6 @@
+import type { MapResult, GherkinScenario } from '../types.js';
+import type { Question, IntakeResult, AmbiguityScore } from './intake-types.js';
+export declare function generateQuestions(features: string[], techReqs: IntakeResult['technicalRequirements']): Question[];
+export declare function generateInterviewQuestions(features: string[], techReqs: IntakeResult['technicalRequirements'], map: MapResult | null): Question[];
+export declare function generateGherkinQuestions(features: string[], existingQuestions: Question[], existingAnswers: Record<string, string>, ambiguity: AmbiguityScore): Question[];
+export declare function generateAcceptanceCriteriaFromAnswers(features: string[], answers: Record<string, string>, doneWhenMap: Record<string, string>): GherkinScenario[];

package/dist/weave/stages/intake-questions.js

@@ -0,0 +1,195 @@
+export function generateQuestions(features, techReqs) {
+    const questions = [];
+    let qId = 1;
+    if (!techReqs.frontend || techReqs.frontend.length === 0) {
+        questions.push({
+            id: `Q${qId++}`,
+            topic: '프론트엔드 기술',
+            question: '프론트엔드 프레임워크 선호도가 있으신가요?',
+            options: ['React', 'Vue', 'Next.js', 'Vanilla JS', '상관없음'],
+            required: true,
+        });
+    }
+    if (!techReqs.database || techReqs.database.length === 0) {
+        questions.push({
+            id: `Q${qId++}`,
+            topic: '데이터 저장',
+            question: '데이터를 어디에 저장할까요?',
+            options: ['로컬 스토리지 (오프라인)', '서버 DB (PostgreSQL/MySQL)', '클라우드 (Supabase/Firebase)'],
+            required: true,
+        });
+    }
+    if (features.length > 3) {
+        questions.push({
+            id: `Q${qId++}`,
+            topic: '우선순위',
+            question: '가장 먼저 완성해야 하는 기능은 무엇인가요?',
+            options: features.slice(0, 5),
+            required: true,
+        });
+    }
+    return questions;
+}
+export function generateInterviewQuestions(features, techReqs, map) {
+    const questions = generateQuestions(features, techReqs);
+    if (map && map.structuralIssues.length > 0) {
+        const critical = map.structuralIssues.filter(i => i.severity === 'critical');
+        const warnings = map.structuralIssues.filter(i => i.severity === 'warning');
+        if (critical.length > 0) {
+            questions.unshift({
+                id: 'MAP-CRITICAL',
+                topic: '구조적 문제',
+                question: `코드베이스에서 ${critical.length}개의 Critical 이슈가 발견되었습니다. 계속 진행할까요?`,
+                options: ['이슈를 먼저 해결', '진행하되 build 단계에서 해결', '지금은 무시'],
+                required: true,
+            });
+        }
+        if (warnings.length > 0) {
+            questions.push({
+                id: 'MAP-WARNINGS',
+                topic: '권장 구조 변경',
+                question: `${warnings.length}개의 경고가 있습니다. 구조 변경 권장사항을 검토하시겠습니까?`,
+                options: ['검토', '나중에 검토', '무시'],
+                required: false,
+            });
+        }
+    }
+    if (features.length > 0) {
+        questions.push({
+            id: 'EXISTING-CODE',
+            topic: '기존 코드 활용',
+            question: '기존 코드베이스의 구조나 패턴을 유지하면서 구현하시겠습니까?',
+            options: ['최대한 기존 구조 유지', '필요시 구조 변경', '새로 작성'],
+            required: true,
+        });
+    }
+    return questions;
+}
+export function generateGherkinQuestions(features, existingQuestions, existingAnswers, ambiguity) {
+    const questions = [];
+    let qId = existingQuestions.length + 1;
+    if (ambiguity.weakestArea === 'Success Criteria Clarity' || ambiguity.overallScore > 0.3) {
+        for (let i = 0; i < Math.min(features.length, 3); i++) {
+            const feature = features[i];
+            const givenAnswered = Object.keys(existingAnswers).some(k => k.includes(`given-${i}`) || k.includes(`전제-${i}`));
+            if (!givenAnswered) {
+                questions.push({
+                    id: `Q${qId++}`,
+                    topic: 'Gherkin - Given',
+                    question: `"${feature}" 기능을 사용하기 전에 어떤 전제조건이 필요합니까? (예: 로그인 되어 있어야 한다, 데이터가 존재해야 한다)`,
+                    required: true,
+                    questionType: 'gherkin-given',
+                    targetFeature: feature,
+                });
+            }
+            const whenAnswered = Object.keys(existingAnswers).some(k => k.includes(`when-${i}`) || k.includes(`행동-${i}`));
+            if (!whenAnswered) {
+                questions.push({
+                    id: `Q${qId++}`,
+                    topic: 'Gherkin - When',
+                    question: `"${feature}" 기능을 실행하기 위해 사용자가 어떤 행동을 하나요? (예: 버튼을 클릭한다, 값을 입력하고 제출한다)`,
+                    required: true,
+                    questionType: 'gherkin-when',
+                    targetFeature: feature,
+                });
+            }
+            const thenAnswered = Object.keys(existingAnswers).some(k => k.includes(`then-${i}`) || k.includes(`결과-${i}`));
+            if (!thenAnswered) {
+                questions.push({
+                    id: `Q${qId++}`,
+                    topic: 'Gherkin - Then',
+                    question: `"${feature}" 기능 실행 후 어떤 결과가 나와야 하나요? (예: 성공 메시지가 표시된다, 데이터가 저장된다, 화면이 갱신된다)`,
+                    required: true,
+                    questionType: 'gherkin-then',
+                    targetFeature: feature,
+                });
+            }
+        }
+    }
+    if (ambiguity.weakestArea === 'Constraint Clarity' || ambiguity.breakdown.constraintClarity.clarityScore < 0.5) {
+        const edgeAnswered = Object.keys(existingAnswers).some(k => k.includes('edge') || k.includes('예외') || k.includes('에러'));
+        if (!edgeAnswered) {
+            questions.push({
+                id: `Q${qId++}`,
+                topic: '경계 조건',
+                question: '비정상적인 상황(네트워크 오류, 잘못된 입력, 권한 없음 등)에서 어떻게 동작해야 하나요?',
+                required: true,
+                questionType: 'edge-case',
+            });
+        }
+        const constraintAnswered = Object.keys(existingAnswers).some(k => k.includes('constraint') || k.includes('제약') || k.includes('제한'));
+        if (!constraintAnswered) {
+            questions.push({
+                id: `Q${qId++}`,
+                topic: '제약조건',
+                question: '기술적/비기능적 제약조건이 있나요? (지원 브라우저, 성능 목표, 보안 요구사항, 데이터 제한 등)',
+                required: false,
+                questionType: 'constraint',
+            });
+        }
+    }
+    if (ambiguity.weakestArea === 'Goal Clarity' || ambiguity.breakdown.goalClarity.clarityScore < 0.5) {
+        const successAnswered = Object.keys(existingAnswers).some(k => k.includes('성공') || k.includes('측정') || k.includes('metric'));
+        if (!successAnswered) {
+            questions.push({
+                id: `Q${qId++}`,
+                topic: '성공 지표',
+                question: '이 프로젝트의 성공을 어떻게 측정할 수 있을까요? (예: 사용자 100명 가입, 페이지 로드 2초 이내, 테스트 통과율 95%)',
+                required: false,
+                questionType: 'clarification',
+            });
+        }
+    }
+    return questions;
+}
+function findAnswer(answers, ...keys) {
+    for (const [k, v] of Object.entries(answers)) {
+        for (const key of keys) {
+            if (k.toLowerCase().includes(key.toLowerCase()))
+                return v;
+        }
+    }
+    return undefined;
+}
+export function generateAcceptanceCriteriaFromAnswers(features, answers, doneWhenMap) {
+    const scenarios = [];
+    for (let i = 0; i < features.length; i++) {
+        const feature = features[i];
+        const doneWhen = doneWhenMap[feature] || `유저가 ${feature} 기능을 사용할 수 있다`;
+        const givenAnswer = findAnswer(answers, `given-${i}`, `전제-${i}`, feature, 'given');
+        const whenAnswer = findAnswer(answers, `when-${i}`, `행동-${i}`, feature, 'when');
+        const thenAnswer = findAnswer(answers, `then-${i}`, `결과-${i}`, feature, 'then');
+        const happyGiven = givenAnswer ? [givenAnswer] : [`${feature} 관련 기능이 구현되어 있다`];
+        const happyWhen = whenAnswer ? [whenAnswer] : [`유저가 ${feature} 기능을 사용한다`];
+        const happyThen = thenAnswer
+            ? [thenAnswer, doneWhen].filter((v, idx, arr) => arr.indexOf(v) === idx)
+            : [doneWhen];
+        scenarios.push({
+            feature,
+            scenario: `${feature} - 정상 동작`,
+            given: happyGiven,
+            when: happyWhen,
+            then: happyThen,
+        });
+        const edgeAnswer = findAnswer(answers, 'edge', '에러', '예외', 'edge-cases');
+        if (edgeAnswer) {
+            scenarios.push({
+                feature,
+                scenario: `${feature} - 에러 처리`,
+                given: [`${feature} 관련 기능이 구현되어 있다`, '비정상적인 상황이 발생한다'],
+                when: ['오류 조건이 발생한다'],
+                then: [edgeAnswer],
+            });
+        }
+        else {
+            scenarios.push({
+                feature,
+                scenario: `${feature} - 에러 처리`,
+                given: [`${feature} 관련 기능이 구현되어 있다`],
+                when: [`유저가 ${feature} 기능을 비정상적으로 사용한다`],
+                then: ['적절한 에러 메시지가 표시된다'],
+            });
+        }
+    }
+    return scenarios;
+}

package/dist/weave/stages/intake-types.d.ts

@@ -0,0 +1,116 @@
+import type { WeaveEvent, EnvironmentAnalysis, MapResult, StructuralChange, ConsentPrompt, GherkinScenario } from '../types.js';
+export interface IntakeOptions {
+    docsPath: string;
+    onEvent?: (event: WeaveEvent) => void;
+}
+export interface IntakeResult {
+    documents: DocumentAnalysis[];
+    features: string[];
+    domainTerms: {
+        term: string;
+        description?: string;
+    }[];
+    technicalRequirements: {
+        frontend?: string[];
+        backend?: string[];
+        database?: string[];
+        other?: string[];
+    };
+    questions: Question[];
+    similarProjects?: string[];
+    environment?: EnvironmentAnalysis;
+    codebaseMapPath?: string;
+    structuralChanges?: StructuralChange[];
+    consentPrompts?: ConsentPrompt[];
+    ambiguityScore?: AmbiguityScore;
+    generatedScenarios?: GherkinScenario[];
+}
+export interface DocumentAnalysis {
+    path: string;
+    title: string;
+    sections: string[];
+    keyPoints: string[];
+}
+export interface Question {
+    id: string;
+    topic: string;
+    question: string;
+    options?: string[];
+    required: boolean;
+    questionType?: 'clarification' | 'gherkin-given' | 'gherkin-when' | 'gherkin-then' | 'edge-case' | 'constraint' | 'priority' | 'technical';
+    targetFeature?: string;
+}
+export interface AmbiguityComponent {
+    name: string;
+    clarityScore: number;
+    weight: number;
+    justification: string;
+    thresholds: {
+        label: string;
+        minScore: number;
+        description: string;
+    }[];
+}
+export interface AmbiguityBreakdown {
+    goalClarity: AmbiguityComponent;
+    constraintClarity: AmbiguityComponent;
+    successCriteriaClarity: AmbiguityComponent;
+    contextClarity?: AmbiguityComponent;
+}
+export interface AmbiguityScore {
+    overallScore: number;
+    breakdown: AmbiguityBreakdown;
+    isReadyForSeed: boolean;
+    readinessForGherkin: boolean;
+    milestone: 'initial' | 'progress' | 'refined' | 'ready';
+    milestoneDescription: string;
+    weakestArea: string;
+    nextMilestone?: {
+        threshold: number;
+        label: string;
+        description: string;
+    };
+}
+export interface InterviewRound {
+    roundNumber: number;
+    questions: Question[];
+    answers: Record<string, string>;
+    ambiguityBefore?: AmbiguityScore;
+    ambiguityAfter?: AmbiguityScore;
+    gherkinGenerated?: GherkinScenario[];
+    timestamp: string;
+}
+export interface InterviewState {
+    interviewId: string;
+    status: 'in_progress' | 'completed' | 'aborted';
+    initialContext: string;
+    rounds: InterviewRound[];
+    currentRound: number;
+    features: string[];
+    isBrownfield: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface InterviewOptions {
+    docsPath: string;
+    basePath?: string;
+    mapResult?: MapResult | null;
+    onEvent?: (event: WeaveEvent) => void;
+    resumeId?: string;
+    userAnswers?: Record<string, string>;
+    skipGherkinQuestions?: boolean;
+}
+export interface InterviewResult {
+    intake: IntakeResult;
+    agreedStructuralChanges: StructuralChange[];
+    userAnswers: Record<string, string>;
+    satisfied: boolean;
+    ambiguityScore?: AmbiguityScore;
+    generatedScenarios?: GherkinScenario[];
+    interviewState?: InterviewState;
+    isMultiRound?: boolean;
+}
+export interface IntakeWithAnalysisOptions extends IntakeOptions {
+    skipEnvironmentAnalysis?: boolean;
+    warningsOnly?: boolean;
+}

package/dist/weave/stages/intake-types.js

@@ -0,0 +1 @@
+export {};

package/dist/weave/stages/intake.d.ts

@@ -1,60 +1,13 @@
-import type { WeaveEvent, EnvironmentAnalysis, MapResult, StructuralChange, ConsentPrompt } from '../types.js';
-export interface IntakeOptions {
-    docsPath: string;
-    onEvent?: (event: WeaveEvent) => void;
-}
-export interface IntakeResult {
-    documents: DocumentAnalysis[];
-    features: string[];
-    domainTerms: {
-        term: string;
-        description?: string;
-    }[];
-    technicalRequirements: {
-        frontend?: string[];
-        backend?: string[];
-        database?: string[];
-        other?: string[];
-    };
-    questions: Question[];
-    similarProjects?: string[];
-    environment?: EnvironmentAnalysis;
-    codebaseMapPath?: string;
-    structuralChanges?: StructuralChange[];
-    consentPrompts?: ConsentPrompt[];
-}
-export interface DocumentAnalysis {
-    path: string;
-    title: string;
-    sections: string[];
-    keyPoints: string[];
-}
-export interface Question {
-    id: string;
-    topic: string;
-    question: string;
-    options?: string[];
-    required: boolean;
-}
+import type { MapResult, StructuralChange, ConsentPrompt } from '../types.js';
+export type { IntakeOptions, IntakeResult, DocumentAnalysis, Question, AmbiguityComponent, AmbiguityBreakdown, AmbiguityScore, InterviewRound, InterviewState, InterviewOptions, InterviewResult, IntakeWithAnalysisOptions, } from './intake-types.js';
+export { scoreAmbiguity } from './intake-ambiguity.js';
+export { generateQuestions, generateInterviewQuestions, generateGherkinQuestions, generateAcceptanceCriteriaFromAnswers, } from './intake-questions.js';
+export { saveInterviewState, loadInterviewState, listInterviewStates, getInterviewDir, } from './intake-persistence.js';
+import type { IntakeResult } from './intake-types.js';
 export declare function injectMapContext(map: MapResult | null, features: string[]): Promise<{
     structuralChanges: StructuralChange[];
     consentPrompts: ConsentPrompt[];
 }>;
-export interface InterviewOptions {
-    docsPath: string;
-    basePath?: string;
-    mapResult?: MapResult | null;
-    onEvent?: (event: WeaveEvent) => void;
-}
-export interface InterviewResult {
-    intake: IntakeResult;
-    agreedStructuralChanges: StructuralChange[];
-    userAnswers: Record<string, string>;
-    satisfied: boolean;
-}
-export declare function interview(options: InterviewOptions): Promise<InterviewResult>;
-export interface IntakeWithAnalysisOptions extends IntakeOptions {
-    skipEnvironmentAnalysis?: boolean;
-    warningsOnly?: boolean;
-}
+import type { IntakeOptions, IntakeWithAnalysisOptions, InterviewOptions, InterviewResult } from './intake-types.js';
 export declare function intake(options: IntakeOptions | IntakeWithAnalysisOptions): Promise<IntakeResult>;
+export declare function interview(options: InterviewOptions): Promise<InterviewResult>;