maskweaver 0.9.6 → 0.9.8

package/dist/plugin/index.js

@@ -16,7 +16,7 @@ import { createMaskSaveTool } from './tools/maskSave.js';
 import { createSquadTool } from './tools/squad.js';
 import { createWeaveTool } from './tools/weave.js';
 import { createSlashcommandTool } from './tools/slashcommand.js';
-import { generatePoolAgentFilesFromConfig, writeDefaultRuntimeConfig, writeDefaultPluginConfig, } from '../shared/generate-agents.js';
+import { generatePoolAgentFilesFromConfig, writeDefaultRuntimeConfig, writeDefaultPluginConfig, writeAutoDetectedConfig, } from '../shared/generate-agents.js';
 const BUILD_COMMAND_TEMPLATE = `Use the \`weave\` tool with \`command="build"\`.
 
 Forward the user arguments from \`$ARGUMENTS\` to the build command:
@@ -34,6 +34,13 @@ const REMOVED_WEAVE_COMMAND_FILES = [
     'weave-task.md',
     'weave-task-auto.md',
     'wave-task-auto.md',
+    'weave-approve-plan.md',
+    'weave-design.md',
+    'weave-flow.md',
+    'weave-plan.md',
+    'weave-research.md',
+    'weave-spec.md',
+    'weave-switch.md',
 ];
 function getAssetsDir() {
     try {
@@ -628,7 +635,11 @@ export const MaskweaverPlugin = async ({ client, directory, project, worktree, $
     if (createdGlobalConfig) {
         pluginLog(client, 'info', `Created global config: ${path.relative(os.homedir(), createdGlobalConfig)}`);
     }
-    const createdRuntimeConfig = writeDefaultRuntimeConfig(directory);
+    const autoDetected = writeAutoDetectedConfig(directory);
+    if (autoDetected) {
+        pluginLog(client, 'info', `Auto-detected subscription: ${autoDetected.detection.primary} (${autoDetected.detection.subscriptions.join(', ')}) — created ${path.relative(directory, autoDetected.path)}`);
+    }
+    const createdRuntimeConfig = !autoDetected ? writeDefaultRuntimeConfig(directory) : null;
     if (createdRuntimeConfig) {
         pluginLog(client, 'info', `Created project config: ${path.relative(directory, createdRuntimeConfig)}`);
     }

package/dist/shared/generate-agents.d.ts

@@ -17,6 +17,28 @@ export declare function generatePoolAgentFiles(pool: ModelPoolEntry[], agentsDir
 export declare function generatePoolAgentFilesFromConfig(projectDir: string, agentsDir: string, options?: {
     force?: boolean;
 }): GenerateAgentsResult;
+export type DetectedSubscription = 'opencode-go' | 'zai-coding-plan';
+export interface SubscriptionDetectionResult {
+    subscriptions: DetectedSubscription[];
+    primary: DetectedSubscription;
+    evidence: string[];
+    allProviders: ProviderInfo[];
+}
+export interface ProviderInfo {
+    name: string;
+    subscription: DetectedSubscription | null;
+    authType: string;
+    active: boolean;
+}
+export declare function detectSubscriptionsFromCli(): SubscriptionDetectionResult;
+export declare function detectSubscriptionsFromConfig(opencodeConfig: Record<string, any>): SubscriptionDetectionResult;
+export declare function buildPoolFromDetection(detection: SubscriptionDetectionResult): any[];
+export declare function buildConfigFromDetection(detection: SubscriptionDetectionResult): Record<string, any>;
+export declare function formatProviderChecklist(detection: SubscriptionDetectionResult): string;
+export declare function writeAutoDetectedConfig(projectDir: string): {
+    path: string;
+    detection: SubscriptionDetectionResult;
+} | null;
 export declare const DEFAULT_RUNTIME_CONFIG_TEMPLATE: {
     readonly dummyHumans: {
         readonly pool: readonly [{

package/dist/shared/generate-agents.js

@@ -100,6 +100,343 @@ export function generatePoolAgentFilesFromConfig(projectDir, agentsDir, options
         errors: ['No maskweaver.config.json found with dummyHumans configuration. Create one or run `weave init-config` to generate a default.'],
     };
 }
+import { spawnSync } from 'node:child_process';
+function readOpencodeConfig(basePath) {
+    const candidates = [
+        path.join(basePath, 'opencode.json'),
+        path.join(basePath, 'opencode.jsonc'),
+        path.join(os.homedir(), '.config', 'opencode', 'opencode.json'),
+        path.join(os.homedir(), '.config', 'opencode', 'opencode.jsonc'),
+    ];
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate))
+            continue;
+        try {
+            let content = fs.readFileSync(candidate, 'utf-8');
+            content = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            const parsed = JSON.parse(content);
+            if (parsed && typeof parsed === 'object')
+                return parsed;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function runCli(command, args) {
+    try {
+        const result = spawnSync(command, args, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 8000,
+            windowsHide: true,
+        });
+        if (result.error || result.status !== 0)
+            return null;
+        return result.stdout || null;
+    }
+    catch {
+        return null;
+    }
+}
+const PROVIDER_MAP = {
+    'opencode go': 'opencode-go',
+    'opencode-go': 'opencode-go',
+    'z.ai coding plan': 'zai-coding-plan',
+    'zai-coding-plan': 'zai-coding-plan',
+    'z.ai': 'zai-coding-plan',
+};
+function parseProvidersList(output) {
+    const providers = [];
+    const lines = output.split('\n');
+    for (const line of lines) {
+        const stripped = line.replace(/\x1b\[[0-9;]*m/g, '').trim();
+        if (!stripped || stripped.startsWith('┌') || stripped.startsWith('└') || stripped.startsWith('│') || stripped.includes('credentials') || stripped.includes('environment'))
+            continue;
+        const match = stripped.match(/[●○◉◘]\s+(.+?)\s+(api|oauth|env)$/i);
+        if (match) {
+            const name = match[1].trim();
+            const authType = match[2].trim();
+            let subscription = null;
+            const nameLower = name.toLowerCase();
+            for (const [key, sub] of Object.entries(PROVIDER_MAP)) {
+                if (nameLower.includes(key)) {
+                    subscription = sub;
+                    break;
+                }
+            }
+            providers.push({
+                name,
+                subscription,
+                authType,
+                active: stripped.includes('●'),
+            });
+        }
+    }
+    return providers;
+}
+function detectFromModels(output) {
+    const subs = new Set();
+    for (const line of output.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('opencode-go/'))
+            subs.add('opencode-go');
+        if (trimmed.startsWith('zai-coding-plan/'))
+            subs.add('zai-coding-plan');
+    }
+    return Array.from(subs);
+}
+export function detectSubscriptionsFromCli() {
+    const evidence = [];
+    const allProviders = [];
+    const subs = new Set();
+    const providersOutput = runCli('opencode', ['providers', 'list']);
+    if (providersOutput) {
+        const providers = parseProvidersList(providersOutput);
+        allProviders.push(...providers);
+        for (const p of providers) {
+            if (p.subscription) {
+                subs.add(p.subscription);
+                evidence.push(`provider: ${p.name} (${p.authType})`);
+            }
+        }
+    }
+    const modelsOutput = runCli('opencode', ['models']);
+    if (modelsOutput) {
+        const modelSubs = detectFromModels(modelsOutput);
+        for (const sub of modelSubs) {
+            if (!subs.has(sub)) {
+                subs.add(sub);
+                evidence.push(`models: ${sub}/* models available`);
+            }
+        }
+    }
+    if (subs.size === 0) {
+        subs.add('opencode-go');
+        evidence.push('No subscription detected via CLI, defaulting to opencode-go');
+    }
+    const primary = subs.has('zai-coding-plan') ? 'zai-coding-plan' : 'opencode-go';
+    return {
+        subscriptions: Array.from(subs),
+        primary,
+        evidence,
+        allProviders,
+    };
+}
+export function detectSubscriptionsFromConfig(opencodeConfig) {
+    const subs = new Set();
+    const evidence = [];
+    const modelFields = ['model', 'small_model', 'large_model'];
+    const configs = [opencodeConfig];
+    if (opencodeConfig.agent) {
+        for (const agentConfig of Object.values(opencodeConfig.agent)) {
+            if (agentConfig && typeof agentConfig === 'object')
+                configs.push(agentConfig);
+        }
+    }
+    for (const cfg of configs) {
+        for (const field of modelFields) {
+            const val = cfg[field];
+            if (typeof val !== 'string' || !val)
+                continue;
+            if (val.startsWith('opencode-go/')) {
+                subs.add('opencode-go');
+                evidence.push(`${field}: ${val}`);
+            }
+            else if (val.startsWith('zai-coding-plan/')) {
+                subs.add('zai-coding-plan');
+                evidence.push(`${field}: ${val}`);
+            }
+        }
+    }
+    if (subs.size === 0) {
+        subs.add('opencode-go');
+        evidence.push('No provider detected in config, defaulting to opencode-go');
+    }
+    const primary = subs.has('zai-coding-plan') ? 'zai-coding-plan' : 'opencode-go';
+    return {
+        subscriptions: Array.from(subs),
+        primary,
+        evidence,
+        allProviders: [],
+    };
+}
+function buildZaiPool() {
+    return [
+        {
+            id: 'glm-flash',
+            model: 'zai-coding-plan/glm-5-turbo',
+            tier: 'flash',
+            maxConcurrent: 1,
+            capabilities: ['search', 'formatting', 'simple-coding', 'file-ops'],
+            costTier: 'low',
+            description: 'GLM-5 Turbo - 빠름. 단순 검색/포매팅/파일작업',
+        },
+        {
+            id: 'glm-general',
+            model: 'zai-coding-plan/glm-5.1',
+            tier: 'human',
+            maxConcurrent: 10,
+            capabilities: ['coding', 'testing', 'refactoring', 'backend'],
+            costTier: 'medium',
+            description: 'GLM-5.1 - 일반. 코딩/리팩토링/백엔드',
+        },
+        {
+            id: 'glm-premium',
+            model: 'zai-coding-plan/glm-5.1',
+            tier: 'premium',
+            maxConcurrent: 10,
+            capabilities: ['architecture', 'debugging', 'reasoning', 'complex-coding', 'refactoring'],
+            costTier: 'high',
+            description: 'GLM-5.1 - 고급 추론. 아키텍처/복잡 디버깅',
+        },
+    ];
+}
+function buildOpencodeGoPool() {
+    return [
+        {
+            id: 'deepseek-flash',
+            model: 'opencode-go/deepseek-v4-flash',
+            tier: 'flash',
+            maxConcurrent: 5,
+            capabilities: ['search', 'formatting', 'simple-coding', 'file-ops'],
+            costTier: 'low',
+            description: 'DeepSeek V4 Flash - 빠름. 단순 검색/포매팅/파일작업',
+        },
+        {
+            id: 'deepseek-general',
+            model: 'opencode-go/deepseek-v4-flash',
+            tier: 'human',
+            maxConcurrent: 3,
+            capabilities: ['coding', 'testing', 'refactoring', 'backend'],
+            costTier: 'medium',
+            description: 'DeepSeek V4 Flash - 일반. 코딩/리팩토링/백엔드',
+        },
+        {
+            id: 'qwen-vision',
+            model: 'opencode-go/qwen3.6-plus',
+            tier: 'human',
+            maxConcurrent: 3,
+            capabilities: ['vision', 'frontend', 'testing'],
+            costTier: 'medium',
+            description: 'Qwen 3.6 Plus - 비전. 이미지 분석/프론트엔드/테스트',
+        },
+        {
+            id: 'deepseek-pro',
+            model: 'opencode-go/deepseek-v4-pro',
+            tier: 'premium',
+            maxConcurrent: 2,
+            capabilities: ['architecture', 'debugging', 'reasoning', 'complex-coding', 'refactoring'],
+            costTier: 'high',
+            description: 'DeepSeek V4 Pro - 고급 추론. 아키텍처/복잡 디버깅',
+        },
+        {
+            id: 'kimi-vision',
+            model: 'opencode-go/kimi-k2.6',
+            tier: 'premium',
+            maxConcurrent: 2,
+            capabilities: ['vision', 'reasoning', 'complex-coding', 'architecture', 'debugging'],
+            costTier: 'high',
+            description: 'Kimi K2.6 - 비전 고급. 이미지 분석/복잡 추론',
+        },
+    ];
+}
+function buildOperatorModel(primary) {
+    switch (primary) {
+        case 'zai-coding-plan':
+            return {
+                model: 'zai-coding-plan/glm-5.1',
+                maxConcurrent: 10,
+                description: 'Squad Operator model - 작업 오케스트레이션 및 고급 추론',
+            };
+        default:
+            return {
+                model: 'opencode-go/deepseek-v4-pro',
+                maxConcurrent: 2,
+                description: 'Squad Operator model - 작업 오케스트레이션 및 고급 추론',
+            };
+    }
+}
+export function buildPoolFromDetection(detection) {
+    const pool = [];
+    if (detection.subscriptions.includes('opencode-go')) {
+        pool.push(...buildOpencodeGoPool());
+    }
+    if (detection.subscriptions.includes('zai-coding-plan')) {
+        pool.push(...buildZaiPool());
+    }
+    if (pool.length === 0) {
+        pool.push(...buildOpencodeGoPool());
+    }
+    return pool;
+}
+export function buildConfigFromDetection(detection) {
+    const pool = buildPoolFromDetection(detection);
+    const operator = buildOperatorModel(detection.primary);
+    return {
+        dummyHumans: { pool },
+        operator,
+        memory: { provider: 'text-only', enabled: false },
+        gdc: { enabled: 'auto', strictVerify: false, autoSyncOnPrepare: true },
+        language: 'ko',
+    };
+}
+export function formatProviderChecklist(detection) {
+    const lines = ['감지된 프로바이더:'];
+    lines.push('');
+    if (detection.allProviders.length > 0) {
+        for (const p of detection.allProviders) {
+            const marker = p.subscription && detection.subscriptions.includes(p.subscription) ? '[x]' : '[ ]';
+            const sub = p.subscription ? ` → ${p.subscription}` : '';
+            lines.push(`  ${marker} ${p.name} (${p.authType})${sub}`);
+        }
+    }
+    else {
+        for (const sub of detection.subscriptions) {
+            lines.push(`  [x] ${sub}`);
+        }
+        lines.push(`  [ ] (다른 구독이 있다면 maskweaver.config.json에서 추가하세요)`);
+    }
+    lines.push('');
+    lines.push(`선택된 구독: ${detection.subscriptions.join(', ')}`);
+    lines.push(`기본 구독: ${detection.primary}`);
+    lines.push('');
+    lines.push('구독을 변경하려면 maskweaver.config.json의 dummyHumans.pool을 편집하세요.');
+    return lines.join('\n');
+}
+export function writeAutoDetectedConfig(projectDir) {
+    let detection;
+    try {
+        detection = detectSubscriptionsFromCli();
+    }
+    catch {
+        const opencodeConfig = readOpencodeConfig(projectDir);
+        if (!opencodeConfig)
+            return null;
+        detection = detectSubscriptionsFromConfig(opencodeConfig);
+    }
+    const targetPath = path.join(projectDir, 'maskweaver.config.json');
+    const existingConfig = fs.existsSync(targetPath)
+        ? (() => { try {
+            return JSON.parse(fs.readFileSync(targetPath, 'utf-8'));
+        }
+        catch {
+            return null;
+        } })()
+        : null;
+    if (existingConfig?.dummyHumans?.pool?.length > 0) {
+        return null;
+    }
+    const newConfig = buildConfigFromDetection(detection);
+    try {
+        fs.writeFileSync(targetPath, JSON.stringify(newConfig, null, 2) + '\n', 'utf-8');
+        return { path: targetPath, detection };
+    }
+    catch {
+        return null;
+    }
+}
 export const DEFAULT_RUNTIME_CONFIG_TEMPLATE = {
     dummyHumans: {
         pool: [
@@ -185,6 +522,10 @@ export function writeDefaultRuntimeConfig(projectDir) {
     if (fs.existsSync(targetPath)) {
         return null;
     }
+    const autoResult = writeAutoDetectedConfig(projectDir);
+    if (autoResult) {
+        return autoResult.path;
+    }
     try {
         fs.writeFileSync(targetPath, JSON.stringify(DEFAULT_RUNTIME_CONFIG_TEMPLATE, null, 2) + '\n', 'utf-8');
         return targetPath;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.9.6";
+export declare const VERSION = "0.9.8";
 export declare function getVersionString(): string;

package/dist/version.js

@@ -1,4 +1,4 @@
-export const VERSION = '0.9.6';
+export const VERSION = '0.9.8';
 export function getVersionString() {
     return `Maskweaver v${VERSION}`;
 }

package/dist/weave/gherkin.d.ts

@@ -0,0 +1,43 @@
+import type { GherkinScenario, WeavePhase, WeaveTask } from './types.js';
+export interface ParsedFeature {
+    feature: string;
+    description: string;
+    scenarios: ParsedScenario[];
+}
+export interface ParsedScenario {
+    name: string;
+    given: string[];
+    when: string[];
+    then: string[];
+}
+export declare function parseGherkinText(text: string): ParsedFeature | null;
+export declare function parseGherkinBlock(block: string): GherkinScenario[];
+export declare function formatGherkinScenario(scenario: GherkinScenario): string;
+export declare function formatGherkinFeature(featureName: string, scenarios: GherkinScenario[]): string;
+export declare function formatGherkinForTask(task: WeaveTask): string;
+export declare function formatGherkinChecklist(scenarios: GherkinScenario[]): string;
+export declare function ensureFeaturesDir(basePath: string): Promise<string>;
+export declare function writeFeatureFile(basePath: string, phaseId: string, phaseName: string, scenarios: GherkinScenario[]): Promise<string>;
+export declare function writeAllFeatureFiles(basePath: string, phases: WeavePhase[]): Promise<Map<string, string>>;
+export declare function generateGherkinForPhase(phase: {
+    id: string;
+    name: string;
+    doneWhen: string;
+}): GherkinScenario[];
+export declare function generateGherkinForTask(task: {
+    id: string;
+    name: string;
+    testCase?: string;
+}, phase: {
+    id: string;
+    name: string;
+    doneWhen: string;
+}): GherkinScenario;
+export interface BDDFrameworkInfo {
+    detected: boolean;
+    framework: 'cucumber' | 'jest-cucumber' | 'pytest-bdd' | 'behave' | 'unknown' | null;
+    testCommand: string | null;
+    featureDir: string | null;
+}
+export declare function detectBDDFramework(projectPath: string): BDDFrameworkInfo;
+export declare function generateGherkinVerificationPrompt(phase: WeavePhase, task?: WeaveTask): string;