maskweaver 0.10.0 → 0.11.0

package/dist/cli/config-manager/npm-dist-tags.d.ts

@@ -0,0 +1,7 @@
+export interface NpmDistTags {
+    latest?: string;
+    beta?: string;
+    next?: string;
+    [tag: string]: string | undefined;
+}
+export declare function fetchNpmDistTags(packageName: string): Promise<NpmDistTags | null>;

package/dist/cli/config-manager/npm-dist-tags.js

@@ -0,0 +1,15 @@
+const NPM_FETCH_TIMEOUT_MS = 5000;
+export async function fetchNpmDistTags(packageName) {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/-/package/${encodeURIComponent(packageName)}/dist-tags`, {
+            signal: AbortSignal.timeout(NPM_FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cli/config-manager/plugin-name-with-version.d.ts

@@ -0,0 +1 @@
+export declare function getPluginNameWithVersion(currentVersion: string, packageName: string): Promise<string>;

package/dist/cli/config-manager/plugin-name-with-version.js

@@ -0,0 +1,21 @@
+import { fetchNpmDistTags } from "./npm-dist-tags.js";
+const PRIORITIZED_TAGS = ["latest", "beta", "next"];
+function getFallbackEntry(version, packageName) {
+    const prereleaseMatch = version.match(/-([a-zA-Z][a-zA-Z0-9-]*)(?:\.|$)/);
+    if (prereleaseMatch) {
+        return `${packageName}@${prereleaseMatch[1]}`;
+    }
+    return packageName;
+}
+export async function getPluginNameWithVersion(currentVersion, packageName) {
+    const distTags = await fetchNpmDistTags(packageName);
+    if (distTags) {
+        const allTags = new Set([...PRIORITIZED_TAGS, ...Object.keys(distTags)]);
+        for (const tag of allTags) {
+            if (distTags[tag] === currentVersion) {
+                return `${packageName}@${tag}`;
+            }
+        }
+    }
+    return getFallbackEntry(currentVersion, packageName);
+}

package/dist/cli/config-manager/version-compatibility.d.ts

@@ -0,0 +1,9 @@
+export interface VersionCompatibility {
+    canUpgrade: boolean;
+    reason?: string;
+    isDowngrade: boolean;
+    isMajorBump: boolean;
+    requiresMigration: boolean;
+}
+export declare function checkVersionCompatibility(currentVersion: string | null, newVersion: string): VersionCompatibility;
+export declare function extractVersionFromPluginEntry(entry: string): string | null;

package/dist/cli/config-manager/version-compatibility.js

@@ -0,0 +1,81 @@
+function parseVersion(version) {
+    const clean = version.replace(/^v/, "").split("-")[0];
+    return clean.split(".").map(Number);
+}
+function compareVersions(a, b) {
+    const partsA = parseVersion(a);
+    const partsB = parseVersion(b);
+    const maxLen = Math.max(partsA.length, partsB.length);
+    for (let i = 0; i < maxLen; i++) {
+        const numA = partsA[i] ?? 0;
+        const numB = partsB[i] ?? 0;
+        if (numA !== numB) {
+            return numA - numB;
+        }
+    }
+    return 0;
+}
+export function checkVersionCompatibility(currentVersion, newVersion) {
+    if (!currentVersion) {
+        return {
+            canUpgrade: true,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+    const cleanCurrent = currentVersion.replace(/^v/, "");
+    const cleanNew = newVersion.replace(/^v/, "");
+    try {
+        const comparison = compareVersions(cleanNew, cleanCurrent);
+        if (comparison < 0) {
+            return {
+                canUpgrade: false,
+                reason: `Downgrade from ${currentVersion} to ${newVersion} is not allowed`,
+                isDowngrade: true,
+                isMajorBump: false,
+                requiresMigration: false,
+            };
+        }
+        if (comparison === 0) {
+            return {
+                canUpgrade: true,
+                reason: `Version ${newVersion} is already installed`,
+                isDowngrade: false,
+                isMajorBump: false,
+                requiresMigration: false,
+            };
+        }
+        const currentMajor = cleanCurrent.split(".")[0];
+        const newMajor = cleanNew.split(".")[0];
+        const isMajorBump = currentMajor !== newMajor;
+        if (isMajorBump) {
+            return {
+                canUpgrade: true,
+                reason: `Major version upgrade from ${currentVersion} to ${newVersion} - configuration migration may be required`,
+                isDowngrade: false,
+                isMajorBump: true,
+                requiresMigration: true,
+            };
+        }
+        return {
+            canUpgrade: true,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+    catch {
+        return {
+            canUpgrade: true,
+            reason: `Unable to compare versions ${currentVersion} and ${newVersion} - proceeding with caution`,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+}
+export function extractVersionFromPluginEntry(entry) {
+    const match = entry.match(/@(.+)$/);
+    return match ? match[1] : null;
+}

package/dist/cli/install.js

@@ -7,8 +7,10 @@ import { VERSION } from "../version.js";
 import { runDoctor, printDoctorReport } from "./doctor.js";
 import { writeDefaultRuntimeConfig, writeDefaultPluginConfig } from "../shared/generate-agents.js";
 const PLUGIN_NAME = "maskweaver";
+const PLUGIN_LATEST = "maskweaver@latest";
 const LEGACY_PLUGIN_NAMES = ["maskweaver/plugin", "@maskweaver/plugin"];
-const ALL_PLUGIN_NAMES = [PLUGIN_NAME, ...LEGACY_PLUGIN_NAMES];
+const ALL_PLUGIN_NAMES = [PLUGIN_NAME, PLUGIN_LATEST, ...LEGACY_PLUGIN_NAMES];
+const ALL_BARE_OR_VERSIONED = [PLUGIN_NAME, PLUGIN_LATEST];
 const CONFIG_NAME = "opencode.json";
 const colors = {
     reset: "\x1b[0m",
@@ -83,19 +85,31 @@ function getInstalledPluginEntries(config) {
     return config.plugin.filter((plugin) => ALL_PLUGIN_NAMES.includes(plugin));
 }
 function isPluginInstalled(config) {
-    return getInstalledPluginEntries(config).length > 0;
+    if (!config.plugin || !Array.isArray(config.plugin))
+        return false;
+    return config.plugin.some((p) => ALL_BARE_OR_VERSIONED.some(name => p === name || p.startsWith(`${name}@`)));
 }
 function normalizePluginEntries(config) {
     if (!config.plugin || !Array.isArray(config.plugin)) {
         return { migratedFrom: [], changed: false };
     }
     const migratedFrom = config.plugin.filter((plugin) => LEGACY_PLUGIN_NAMES.includes(plugin));
-    if (migratedFrom.length === 0) {
+    const hasBare = config.plugin.some((p) => p === PLUGIN_NAME);
+    const hasVersioned = config.plugin.some((p) => p.startsWith(`${PLUGIN_NAME}@`));
+    if (migratedFrom.length === 0 && !hasBare && !hasVersioned) {
+        if (config.plugin.some((p) => p === PLUGIN_LATEST)) {
+            return { migratedFrom: [], changed: false };
+        }
         return { migratedFrom: [], changed: false };
     }
-    const preserved = config.plugin.filter((plugin) => !ALL_PLUGIN_NAMES.includes(plugin));
-    config.plugin = [...preserved, PLUGIN_NAME];
-    return { migratedFrom, changed: true };
+    const preserved = config.plugin.filter((plugin) => !ALL_PLUGIN_NAMES.includes(plugin) &&
+        !plugin.startsWith(`${PLUGIN_NAME}@`));
+    const existingVersioned = config.plugin.find((p) => p.startsWith(`${PLUGIN_NAME}@`));
+    config.plugin = [...preserved, existingVersioned || PLUGIN_LATEST];
+    if (migratedFrom.length > 0 || hasBare) {
+        return { migratedFrom: [...migratedFrom, hasBare ? PLUGIN_NAME : ""].filter(Boolean), changed: true };
+    }
+    return { migratedFrom: [], changed: false };
 }
 async function installPlugin(options) {
     const isLocal = options.local || false;
@@ -120,13 +134,14 @@ async function installPlugin(options) {
             log("");
             return;
         }
-        if (config.plugin.includes(PLUGIN_NAME)) {
+        const alreadyInstalled = config.plugin.some((p) => p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`));
+        if (alreadyInstalled) {
             warning(`플러그인이 이미 설치되어 있습니다.`);
-            info(`현재 ${scope} 설정에 등록되어 있습니다: ${PLUGIN_NAME}`);
+            info(`현재 ${scope} 설정에 등록되어 있습니다: ${PLUGIN_LATEST}`);
             log("");
             return;
         }
-        config.plugin.push(PLUGIN_NAME);
+        config.plugin.push(PLUGIN_LATEST);
         writeConfig(configPath, config);
         let createdRuntimeConfig = false;
         let createdPluginConfig = false;
@@ -150,7 +165,7 @@ async function installPlugin(options) {
         }
         success(`플러그인이 성공적으로 설치되었습니다!`);
         log("");
-        log(`📦 설치된 플러그인: ${PLUGIN_NAME}`, "bright");
+        log(`📦 설치된 플러그인: ${PLUGIN_LATEST}`, "bright");
         log(`📍 위치: ${configPath}`, "dim");
         log("");
         log(`다음 단계:`, "bright");
@@ -190,7 +205,7 @@ async function uninstallPlugin(options) {
             log("");
             return;
         }
-        config.plugin = config.plugin.filter((p) => !ALL_PLUGIN_NAMES.includes(p));
+        config.plugin = config.plugin.filter((p) => !ALL_PLUGIN_NAMES.includes(p) && !p.startsWith(`${PLUGIN_NAME}@`));
         writeConfig(configPath, config);
         success(`플러그인이 성공적으로 제거되었습니다.`);
         log("");

package/dist/plugin/index.js

@@ -5,6 +5,8 @@ import * as os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { VERSION } from '../version.js';
+import { fetchNpmDistTags } from '../cli/config-manager/npm-dist-tags.js';
+import { checkVersionCompatibility } from '../cli/config-manager/version-compatibility.js';
 import { loadPluginConfig, isMaskEnabled, isToolEnabled, getDefaultMask, isAutoActivateEnabled, isVerboseLoggingEnabled, isCompletionSoundEnabled, validateConfig, } from './config/index.js';
 import { createMemorySearchTool } from './tools/memorySearch.js';
 import { createMemoryWriteTool } from './tools/memoryWrite.js';
@@ -595,10 +597,10 @@ function playCompletionSound(config) {
 }
 let state = null;
 const OPENCODE_PACKAGES_DIR = path.join(os.homedir(), '.cache', 'opencode', 'packages');
-const MASKWEAVER_PACKAGE_GLOB = 'maskweaver@*';
-function getCacheVersion() {
-    if (!fs.existsSync(OPENCODE_PACKAGES_DIR))
-        return null;
+function getCachedPackageVersion() {
+    if (!fs.existsSync(OPENCODE_PACKAGES_DIR)) {
+        return { version: null, pkgDir: null };
+    }
     const entries = fs.readdirSync(OPENCODE_PACKAGES_DIR);
     for (const entry of entries) {
         if (!entry.startsWith('maskweaver@'))
@@ -615,51 +617,88 @@ function getCacheVersion() {
             continue;
         }
     }
-    return null;
+    return { version: null, pkgDir: null };
 }
-function getLatestNpmVersion() {
-    try {
-        const result = spawnSync('npm', ['view', 'maskweaver', 'version'], {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            timeout: 10000,
-            windowsHide: true,
-        });
-        if (result.status === 0 && result.stdout) {
-            return result.stdout.trim();
-        }
-    }
-    catch { }
-    return null;
+async function fetchLatestFromRegistry() {
+    return fetchNpmDistTags('maskweaver');
 }
-function checkAndInvalidateCache() {
-    const cached = getCacheVersion();
-    if (!cached) {
-        return { invalidated: false, cachedVersion: null, latestVersion: null };
+async function checkForUpdates() {
+    const cached = getCachedPackageVersion();
+    const installedVersion = cached.version;
+    const latestTags = await fetchLatestFromRegistry();
+    const latestVersion = latestTags?.latest ?? null;
+    if (!installedVersion) {
+        return {
+            updateAvailable: false,
+            installedVersion: null,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: null,
+        };
     }
-    if (cached.version === VERSION) {
-        return { invalidated: false, cachedVersion: cached.version, latestVersion: null };
+    if (installedVersion === VERSION) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: null,
+        };
     }
-    const latest = getLatestNpmVersion();
-    if (latest && latest !== cached.version) {
-        try {
-            fs.rmSync(cached.pkgDir, { recursive: true, force: true });
-            return { invalidated: true, cachedVersion: cached.version, latestVersion: latest };
-        }
-        catch {
-            return { invalidated: false, cachedVersion: cached.version, latestVersion: latest };
-        }
+    if (!latestVersion || latestVersion === installedVersion) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: `Plugin cache v${installedVersion} — current is v${VERSION}.`,
+        };
+    }
+    const compatibility = checkVersionCompatibility(installedVersion, latestVersion);
+    const currentIsLatest = installedVersion === latestVersion;
+    if (currentIsLatest) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: `Plugin cache v${installedVersion} — current is v${VERSION}.`,
+        };
     }
-    return { invalidated: false, cachedVersion: cached.version, latestVersion: latest };
+    return {
+        updateAvailable: true,
+        installedVersion,
+        latestVersion,
+        isDowngrade: compatibility.isDowngrade,
+        isMajorBump: compatibility.isMajorBump,
+        requiresMigration: compatibility.requiresMigration,
+        message: `Update available: v${installedVersion} → v${latestVersion}${compatibility.requiresMigration ? ' (major upgrade — migration may be required)' : ''}.`,
+    };
 }
 export const MaskweaverPlugin = async ({ client, directory, project, worktree, $, serverUrl }) => {
-    const cacheCheck = checkAndInvalidateCache();
-    if (cacheCheck.invalidated) {
-        pluginLog(client, 'warn', `Stale plugin cache detected (v${cacheCheck.cachedVersion}). Cleared — v${cacheCheck.latestVersion} will install on next restart.`);
-        pluginLog(client, 'warn', `Please restart OpenCode to activate maskweaver v${VERSION}.`);
+    const updateCheck = await checkForUpdates();
+    if (updateCheck.updateAvailable) {
+        if (updateCheck.isDowngrade) {
+            pluginLog(client, 'warn', `Downgrade detected (v${updateCheck.installedVersion} → v${updateCheck.latestVersion}) — not allowed. Please use opencode --upgrade.`);
+        }
+        else {
+            pluginLog(client, 'warn', `Update available: maskweaver v${updateCheck.installedVersion} → v${updateCheck.latestVersion}`);
+            if (updateCheck.requiresMigration) {
+                pluginLog(client, 'warn', `Major version upgrade — configuration migration may be required.`);
+            }
+            pluginLog(client, 'info', `Run \`opencode --upgrade\` or \`npm update -g maskweaver\` to update.`);
+        }
     }
-    else if (cacheCheck.cachedVersion && cacheCheck.cachedVersion !== VERSION) {
-        pluginLog(client, 'info', `Plugin cache v${cacheCheck.cachedVersion} — current is v${VERSION}. Restart recommended.`);
+    else if (updateCheck.message) {
+        pluginLog(client, 'info', updateCheck.message);
     }
     const pluginConfig = loadPluginConfig(directory, { client, verbose: false });
     const configErrors = validateConfig(pluginConfig);

package/dist/plugin/tools/command-registry.js

@@ -91,7 +91,7 @@ const INLINE_DEFAULT = {
             name: 'craft',
             aliases: [],
             deprecatedAliases: [],
-            description: 'Prepare execution context for a phase (phase auto-select if omitted)',
+            description: '[DEPRECATED] Use build instead — it now auto-approves and runs craft+build+verify',
             category: 'execution',
             args: [
                 { name: 'phaseId', type: 'string', required: false, description: 'Phase ID (auto-select if omitted)' },
@@ -99,7 +99,7 @@ const INLINE_DEFAULT = {
             ],
             mdFile: 'weave-craft.md',
             handler: 'handleCraft',
-            examples: ['weave command=craft', 'weave command=craft phaseId="P1"'],
+            examples: ['weave command=build (use this instead)'],
         },
         {
             name: 'build',
@@ -112,6 +112,7 @@ const INLINE_DEFAULT = {
                 { name: 'phaseIds', type: 'string', required: false, description: 'Comma-separated phase IDs for run action' },
                 { name: 'buildId', type: 'string', required: false, description: 'Build ID for status/stop/resume/sync actions' },
                 { name: 'maxRetries', type: 'number', default: 3, min: 1, max: 10, description: 'Maximum retries per task (for run action)' },
+                { name: 'taskResults', type: 'string', required: false, description: 'JSON array of TaskResult from previous wave (for resume)' },
                 { name: 'maxIterations', type: 'number', default: 1, min: 1, max: 20, description: 'Maximum loop iterations before blocking' },
                 { name: 'maxNoProgress', type: 'number', default: 1, min: 0, max: 10, description: 'Maximum repeated no-progress failures before blocking' },
             ],
@@ -216,12 +217,14 @@ const INLINE_DEFAULT = {
             args: [
                 { name: 'sync', type: 'boolean', default: false, description: 'Force regenerate agent .md files from config pool' },
                 { name: 'init', type: 'boolean', default: false, description: 'Create default maskweaver.config.json with pool template' },
+                { name: 'force', type: 'boolean', default: false, description: 'Force re-detect subscription and overwrite maskweaver.config.json' },
             ],
             mdFile: 'weave-agents.md',
             handler: 'handleAgents',
             examples: [
                 'weave command=agents sync=true',
                 'weave command=agents init=true',
+                'weave command=agents force=true',
             ],
         },
         {

package/dist/plugin/tools/weave.d.ts

@@ -13,6 +13,7 @@ export declare function createWeaveTool(): {
         }>>;
         sync: z.ZodOptional<z.ZodBoolean>;
         init: z.ZodOptional<z.ZodBoolean>;
+        force: z.ZodOptional<z.ZodBoolean>;
         docsPath: z.ZodOptional<z.ZodString>;
         phaseId: z.ZodOptional<z.ZodString>;
         projectName: z.ZodOptional<z.ZodString>;
@@ -56,6 +57,7 @@ export declare function createWeaveTool(): {
         deep: z.ZodOptional<z.ZodBoolean>;
         maxRetries: z.ZodOptional<z.ZodNumber>;
         buildId: z.ZodOptional<z.ZodString>;
+        taskResults: z.ZodOptional<z.ZodString>;
         phaseIds: z.ZodOptional<z.ZodString>;
     };
     execute: (args: {
@@ -97,6 +99,7 @@ export declare function createWeaveTool(): {
         deep?: boolean;
         maxRetries?: number;
         buildId?: string;
+        taskResults?: string;
         phaseIds?: string;
     }, context: {
         worktree: string;