vigthoria-cli 1.11.11 → 1.11.17

package/dist/utils/requestIntent.js

@@ -0,0 +1,170 @@
+/**
+ * Shared prompt intent detection for CLI routing, V3 hints, and rescue gating.
+ * Keep aligned with V3-Code-Agent/agent.py _classify_request heuristics.
+ */
+const CLI_SHAPING_BLOCK = /(?:^|\n\n)Platform:\s*(?:Windows|macOS|Linux)\.[\s\S]*?(?=\n\n[A-Z][^\n]{0,40}:|\s*$)/i;
+const READONLY_SHAPING_BLOCK = /(?:^|\n\n)(?:Read-only analysis mode is active\.|Diagnostic mode is active\.)[\s\S]*?(?=\n\n[A-Z][^\n]{0,40}:|\s*$)/i;
+const BUILD_VERBS = /\b(build|create|make|implement|complete|fix|repair|edit|modify|write|generate|add|finish|scaffold|develop|update|change|refactor|let's|let us|we need|we should|erstelle|erstellen|schreib|schreibe|bearbeite)\b/i;
+const ARTIFACT_NOUNS = /\b(file|files|project|game|spiel|app|website|html5|frontend|component|feature|code|workspace|repo|clone|replica|remake|page|site|canvas|sprite|level|levels|enemy|enemies|character|npc|world|scene|script|module|api|database|config|landing|dashboard|platformer|arcade|playable|collectible|scoreboard|leaderboard|pitfall|pacman|rogue|html|css|javascript|typescript)\b/i;
+/** Canvas/playable games only — bare "html5" or "website" must NOT match. */
+const GAME_INTENT = /\b(game|spiel|playable|html5\s+(?:game|canvas)|html5\s+game|canvas\s+game|game\s+canvas|arcade|platformer|side[- ]?scroller|pitfall|pac[- ]?man|tetris|snake|breakout|pong|roguelike|metroidvania|tower\s+defense|clone\s+of\s+(?:a\s+)?(?:game|pitfall|pac|mario|zelda|arcade)|gameplay|collectible|boss\s+fight|level\s+design|sprite\s+sheet|wild\s+(?:boar|pig|forest)|forest\s+pig)\b/i;
+const WEB_PAGE_INTENT = /\b(website|web\s*site|webpage|web\s*page|landing\s+page|home\s*page|index\.html|html\s+page|static\s+page|single\s+page|popup|alert|modal|hello\s+world)\b/i;
+const CLONE_BUILD = /\bclone\s+of\b|\b(build|create|make)\s+(?:a|an|the|us|me)?\s*(?:clone|replica|remake|port)\b/i;
+const READ_ONLY_INTENT = /\b(analy[sz]e|analyse|analysis|audit|review|inspect|proof|understand|summari[sz]e|scan|read[\s-]?only|where we left|what is|how does|show me|tell me|identify\s+gaps?|gap\s+analysis|production\s+blockers?)\b/i;
+const EXPLICIT_WRITE_VERBS = /\b(implement|write|edit|modify|update|fix|repair|create|build|generate|scaffold|deploy|refactor|develop|integrate)\b/i;
+const TRIVIAL_HTML_PAGE = /\b(hello\s*world|simple\s+(?:html|web|page|site)|html5\s+website|html\s+5\s+website|popup|alert\s*\(|show\s+a\s+popup|one\s+page|single\s+html)\b/i;
+/** Strip CLI-appended platform / mode shaping so it cannot flip quality profiles. */
+export function stripExecutionShaping(prompt) {
+    return String(prompt || '')
+        .replace(CLI_SHAPING_BLOCK, '')
+        .replace(READONLY_SHAPING_BLOCK, '')
+        .trim();
+}
+export function hasBuildVerb(prompt) {
+    return BUILD_VERBS.test(stripExecutionShaping(prompt));
+}
+export function hasArtifactNoun(prompt) {
+    return ARTIFACT_NOUNS.test(stripExecutionShaping(prompt));
+}
+/** Game clones require a game target — generic "clone of X" must not imply game-build. */
+const GAME_CLONE_TARGET = /\bclone\s+of\s+(?:a\s+)?(?:the\s+)?(?:game|pitfall|pac[- ]?man|mario|zelda|tetris|snake|arcade|spiel)\b/i;
+export function hasGameIntent(prompt) {
+    const text = stripExecutionShaping(prompt);
+    if (GAME_INTENT.test(text)) {
+        return true;
+    }
+    if (GAME_CLONE_TARGET.test(text)) {
+        return true;
+    }
+    if (CLONE_BUILD.test(text) && /\b(game|spiel|pitfall|pacman|arcade|platformer|playable|canvas)\b/i.test(text)) {
+        return true;
+    }
+    return false;
+}
+export function isContinueOrRetryPrompt(prompt) {
+    const text = stripExecutionShaping(prompt).toLowerCase();
+    return /\b(continue\s+(?:the\s+)?(?:previous|last|current)\s+(?:agent\s+)?run|\/retry|\/continue|resume\s+(?:the\s+)?(?:failed|unfinished)|planner\s+produced\s+\d+\s+execution\s+tasks)\b/i.test(text);
+}
+export function hasWebPageIntent(prompt) {
+    const text = stripExecutionShaping(prompt);
+    return WEB_PAGE_INTENT.test(text) || /\bhtml5\s+website\b/i.test(text);
+}
+export function isTrivialHtmlPageRequest(prompt) {
+    const text = stripExecutionShaping(prompt);
+    if (isContinueOrRetryPrompt(prompt)) {
+        return false;
+    }
+    if (!hasBuildVerb(prompt) && !/\b(write|create|make|show)\b/i.test(text)) {
+        return false;
+    }
+    if (hasGameIntent(prompt)) {
+        return false;
+    }
+    if (text.length > 420) {
+        return false;
+    }
+    if (/\b(multi[- ]?page|full\s+saas|dashboard|e[\s-]?commerce|auth|database|backend|api|microservice)\b/i.test(text)) {
+        return false;
+    }
+    return TRIVIAL_HTML_PAGE.test(text)
+        || (hasWebPageIntent(prompt) && /\b(html5|html5\s+website|website|popup|hello\s*world)\b/i.test(text));
+}
+export function hasCloneBuildIntent(prompt) {
+    return CLONE_BUILD.test(stripExecutionShaping(prompt)) && hasBuildVerb(prompt);
+}
+export function hasExplicitWriteIntent(prompt) {
+    const text = stripExecutionShaping(prompt);
+    return (BUILD_VERBS.test(text) && ARTIFACT_NOUNS.test(text))
+        || hasCloneBuildIntent(prompt)
+        || (BUILD_VERBS.test(text) && hasGameIntent(prompt));
+}
+export function taskRequiresWorkspaceChanges(prompt) {
+    const text = String(prompt || '').trim();
+    const shaped = stripExecutionShaping(text);
+    const readOnlyIntent = READ_ONLY_INTENT.test(shaped);
+    const explicitWriteIntent = hasExplicitWriteIntent(text);
+    if (readOnlyIntent && !explicitWriteIntent) {
+        return false;
+    }
+    return explicitWriteIntent;
+}
+export function inferAgentTaskType(prompt) {
+    const text = stripExecutionShaping(prompt);
+    if (/\b(inspect|analyze|analyse|audit|review|find|diagnose|debug|trace|compare|diff|check|investigate)\b/i.test(text)
+        && !hasExplicitWriteIntent(prompt)) {
+        return 'debugging';
+    }
+    if (/\b(analy[sz]e|analyse|audit|review|inspect|identify\s+gaps?|gap\s+analysis|production\s+blockers?|read[\s-]?only)\b/i.test(text)
+        && !hasExplicitWriteIntent(prompt)) {
+        return 'analysis';
+    }
+    if (hasBuildVerb(prompt) && !/\b(analy[sz]e|analyse|audit|review|inspect)\b/i.test(text)) {
+        if (hasGameIntent(prompt)) {
+            return 'game-build';
+        }
+        if (hasWebPageIntent(prompt)) {
+            return 'web-build';
+        }
+        return 'implementation';
+    }
+    return 'analysis';
+}
+export function shouldSkipAnalysisRescue(liveOutcome) {
+    if (liveOutcome.requiresWorkspaceChanges) {
+        return true;
+    }
+    if ((liveOutcome.tasksTotal || 0) > 0) {
+        return true;
+    }
+    if ((liveOutcome.changedFileCount || 0) > 0) {
+        return true;
+    }
+    return false;
+}
+export function isPlannerBuildTask(agentTaskType, prompt) {
+    const kind = String(agentTaskType || '').toLowerCase();
+    if (isTrivialHtmlPageRequest(prompt)) {
+        return false;
+    }
+    if (/^(game-build|web-build|implementation|build|repair|refactor-build)$/.test(kind)) {
+        return true;
+    }
+    return hasExplicitWriteIntent(prompt) && !READ_ONLY_INTENT.test(stripExecutionShaping(prompt));
+}
+export function resolvePlannerAgentTimeoutMs(baseTimeoutMs, agentTaskType, prompt) {
+    if (!isPlannerBuildTask(agentTaskType, prompt)) {
+        return baseTimeoutMs;
+    }
+    const raw = process.env.VIGTHORIA_AGENT_PLANNER_TIMEOUT_MS || process.env.V3_AGENT_PLANNER_TIMEOUT_MS || '900000';
+    const extended = Number.parseInt(raw, 10);
+    const floor = Number.isFinite(extended) && extended > 0 ? extended : 900000;
+    return Math.max(baseTimeoutMs, floor);
+}
+/** V3 workflow mode: suppress write path when the user did not ask for file changes. */
+export function resolveWorkflowType(agentTaskType, prompt) {
+    const kind = String(agentTaskType || '').toLowerCase();
+    if (kind === 'analysis' || kind === 'debugging' || kind === 'verification') {
+        return 'analysis_only';
+    }
+    if (!taskRequiresWorkspaceChanges(prompt)) {
+        return 'analysis_only';
+    }
+    return 'full';
+}
+export function buildExecutionHints(agentTaskType, prompt, options = {}) {
+    const workflowType = resolveWorkflowType(agentTaskType, prompt);
+    const kind = String(agentTaskType || 'general').toLowerCase();
+    const hints = {
+        task_kind: kind,
+        requires_file_changes: workflowType === 'analysis_only' ? false : undefined,
+        classify_from: String(prompt || ''),
+        workflow_type: workflowType,
+    };
+    if (options.fastPath) {
+        hints.fast_path = options.fastPath;
+    }
+    else if (isTrivialHtmlPageRequest(prompt)) {
+        hints.fast_path = 'template-instant';
+    }
+    return hints;
+}

package/dist/utils/templateInstantPath.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sub-second path: Template Service match → write index.html (skip V3 planner).
+ */
+import type { APIClient } from './api.js';
+export type TemplateInstantResult = {
+    ok: boolean;
+    entryPath?: string;
+    templateName?: string;
+    confidence?: number;
+    processingMs?: number;
+    error?: string;
+    usedFallback?: boolean;
+};
+export declare function runTemplateInstantPath(api: APIClient, vision: string, workspacePath: string, options?: {
+    entryPath?: string;
+    allowFallback?: boolean;
+    forceMinimalFallback?: boolean;
+}): Promise<TemplateInstantResult>;

package/dist/utils/templateInstantPath.js

@@ -0,0 +1,121 @@
+/**
+ * Sub-second path: Template Service match → write index.html (skip V3 planner).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+function ensurePopupScript(html, vision) {
+    const text = String(vision || '').toLowerCase();
+    if (!/\b(popup|alert|hello\s*world)\b/.test(text)) {
+        return html;
+    }
+    if (/\balert\s*\(/i.test(html)) {
+        return html;
+    }
+    const script = "<script>window.addEventListener('load',()=>alert('Hello World'));</script>";
+    if (/<\/body>/i.test(html)) {
+        return html.replace(/<\/body>/i, `${script}\n</body>`);
+    }
+    return `${html}\n${script}`;
+}
+function minimalHelloWorldHtml(popupMessage = 'Hello World') {
+    const safe = String(popupMessage || 'Hello World').replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Hello World</title>
+  <style>
+    body { font-family: system-ui, sans-serif; display: grid; place-items: center; min-height: 100vh; margin: 0; background: #0a0a1a; color: #e6f0ff; }
+    h1 { font-size: 2rem; }
+  </style>
+</head>
+<body>
+  <h1>Hello World</h1>
+  <script>window.addEventListener('load', () => alert('${safe}'));</script>
+</body>
+</html>
+`;
+}
+async function fetchTemplateMatch(api, vision, timeoutMs = 15000) {
+    const bases = api.getTemplateServiceBaseUrls();
+    let lastError = 'Template Service unreachable';
+    for (const base of bases) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(`${base}/match`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ vision }),
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            const payload = await response.json().catch(() => null);
+            if (!response.ok) {
+                lastError = payload?.error || `HTTP ${response.status} from ${base}`;
+                continue;
+            }
+            if (!payload?.success || !payload?.html) {
+                lastError = payload?.message || payload?.error || 'No template match';
+                continue;
+            }
+            const templateMeta = payload.template;
+            const templateName = typeof templateMeta === 'string'
+                ? templateMeta
+                : (templateMeta?.name || templateMeta?.id);
+            return {
+                html: String(payload.html),
+                template: templateName,
+                confidence: Number(payload.confidence) || 0,
+                processingMs: Number(payload.processing_time || payload.processingTime) || 0,
+            };
+        }
+        catch (err) {
+            clearTimeout(timer);
+            lastError = err?.message || String(err);
+        }
+    }
+    return { error: lastError };
+}
+function extractPopupMessage(vision) {
+    const quoted = vision.match(/popup\s+with\s+["']([^"']+)["']/i);
+    if (quoted?.[1])
+        return quoted[1];
+    if (/\bhello\s*world\b/i.test(vision))
+        return 'Hello World';
+    return 'Hello World';
+}
+export async function runTemplateInstantPath(api, vision, workspacePath, options = {}) {
+    const entryPath = options.entryPath || 'index.html';
+    const target = path.join(workspacePath, entryPath);
+    let html;
+    let usedFallback = false;
+    let match = {};
+    if (options.forceMinimalFallback) {
+        html = minimalHelloWorldHtml(extractPopupMessage(vision));
+        usedFallback = true;
+    }
+    else {
+        match = await fetchTemplateMatch(api, vision);
+        html = match.html;
+        if (!html && options.allowFallback !== false) {
+            html = minimalHelloWorldHtml(extractPopupMessage(vision));
+            usedFallback = true;
+        }
+    }
+    if (!html) {
+        return { ok: false, error: match.error || 'Template match failed' };
+    }
+    html = ensurePopupScript(html, vision);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, html, 'utf8');
+    return {
+        ok: true,
+        entryPath,
+        templateName: match.template || (usedFallback ? 'minimal-hello-world' : undefined),
+        confidence: match.confidence,
+        processingMs: match.processingMs,
+        usedFallback,
+    };
+}

package/dist/utils/v3-workspace-path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Normalize V3 SSE / tool paths to a safe workspace-relative POSIX path.
+ * Decodes vigthoria:// boundary URIs from server scrubbing before local writes.
+ */
+export declare function normalizeV3WorkspaceRelativePath(rawPath: string, rootPath?: string): string;
+/** Join workspace root + relative path without path.resolve URI corruption on Windows. */
+export declare function joinV3WorkspacePath(rootPath: string, relativePath: string): string;

package/dist/utils/v3-workspace-path.js

@@ -0,0 +1,85 @@
+import path from 'path';
+/**
+ * Normalize V3 SSE / tool paths to a safe workspace-relative POSIX path.
+ * Decodes vigthoria:// boundary URIs from server scrubbing before local writes.
+ */
+export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
+    let input = String(rawPath || '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
+    if (!input) {
+        return '';
+    }
+    const safeRelative = (candidate) => {
+        const stripped = String(candidate || '').replace(/^\/+/, '');
+        if (!stripped) {
+            return '';
+        }
+        if (process.platform === 'win32' && /:/.test(stripped) && !/^[a-zA-Z]:/.test(stripped)) {
+            return '';
+        }
+        if (/^[a-zA-Z]:\//.test(stripped)) {
+            return '';
+        }
+        const normalized = path.posix.normalize(stripped);
+        if (!normalized || normalized === '.' || normalized === '..' || normalized.startsWith('../') || path.posix.isAbsolute(normalized)) {
+            return '';
+        }
+        return normalized;
+    };
+    const decodeBoundaryUri = (value) => {
+        const match = value.match(/^vigthoria:\/\/(?:workspace|server-internal)\/?(.*)$/i);
+        if (match) {
+            return safeRelative(match[1] || '');
+        }
+        return null;
+    };
+    const decoded = decodeBoundaryUri(input);
+    if (decoded !== null) {
+        return decoded;
+    }
+    if (/^vigthoria:\/\//i.test(input)) {
+        return '';
+    }
+    const internalWorkspacePatterns = [
+        /^\/?var\/www\/\.vigthoria\/v3-temp\/vig-remote-[^/]+\/(.+)$/i,
+        /^\/?var\/www\/vigthoria:\/\/?server-internal\/?(.+)$/i,
+        /^var\/www\/vigthoria:\/\/?server-internal\/?(.+)$/i,
+        /^var\/www\/vigthoria:\/\/server-internal\/?(.+)$/i,
+        /^\.vigthoria\/v3-temp\/vig-remote-[^/]+\/(.+)$/i,
+        /^\/?tmp\/vig-remote(?:-server)?-[^/]+\/(.+)$/i,
+        /^\/?tmp\/vig-fork-[^/]+\/(.+)$/i,
+        /^\/?home\/user\/(.+)$/i,
+        /^\/?root\/(.+)$/i,
+    ];
+    for (const pattern of internalWorkspacePatterns) {
+        const match = input.match(pattern);
+        if (match && match[1]) {
+            return safeRelative(match[1]);
+        }
+    }
+    const normalizedRoot = String(rootPath || '').trim().replace(/\\/g, '/').replace(/\/+$/g, '');
+    if (normalizedRoot) {
+        const rootNoLeadingSlash = normalizedRoot.replace(/^\//, '');
+        const rootBase = path.posix.basename(normalizedRoot);
+        const prefixes = [
+            `${normalizedRoot}/`,
+            `${rootNoLeadingSlash}/`,
+            `${rootBase}/`,
+        ];
+        for (const prefix of prefixes) {
+            if (input.startsWith(prefix)) {
+                return safeRelative(input.slice(prefix.length));
+            }
+        }
+        const embeddedRoot = `/${rootBase}/`;
+        const embeddedIndex = input.indexOf(embeddedRoot);
+        if (embeddedIndex >= 0) {
+            return safeRelative(input.slice(embeddedIndex + embeddedRoot.length));
+        }
+    }
+    return safeRelative(input);
+}
+/** Join workspace root + relative path without path.resolve URI corruption on Windows. */
+export function joinV3WorkspacePath(rootPath, relativePath) {
+    const segments = relativePath.split('/').filter((segment) => segment && segment !== '.');
+    return path.join(rootPath, ...segments);
+}

package/dist/utils/workspace-stream.js

@@ -22,6 +22,7 @@ import fs from 'fs';
 import path from 'path';
 import WebSocket from 'ws';
 import { Logger } from './logger.js';
+import { joinV3WorkspacePath, normalizeV3WorkspaceRelativePath } from './v3-workspace-path.js';
 const logger = new Logger();
 logger.setVerbose(!!process.env.VIGTHORIA_DEBUG);
 // Files/dirs to ignore in the watcher
@@ -74,9 +75,15 @@ export function applyFileMutation(event, workspaceRoot) {
         return false;
     if (!event.path || !workspaceRoot)
         return false;
-    const absPath = path.resolve(workspaceRoot, event.path);
+    const relativePath = normalizeV3WorkspaceRelativePath(event.path, workspaceRoot);
+    if (!relativePath) {
+        logger.warn(`Refusing to apply mutation with invalid path: ${event.path}`);
+        return false;
+    }
+    const absPath = joinV3WorkspacePath(workspaceRoot, relativePath);
+    const resolvedRoot = path.resolve(workspaceRoot);
     // Safety: ensure the resolved path is within the workspace
-    if (!absPath.startsWith(path.resolve(workspaceRoot) + path.sep) && absPath !== path.resolve(workspaceRoot)) {
+    if (!absPath.startsWith(resolvedRoot + path.sep) && absPath !== resolvedRoot) {
         logger.warn(`Refusing to apply mutation outside workspace: ${event.path}`);
         return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.11.11",
+  "version": "1.11.17",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -41,6 +41,7 @@
     "test:regression": "npm run build && node scripts/test-regression-1.6.22.js",
     "test:agent:smoke": "npm run build && node scripts/test-agent-smoke.js",
     "test:agent:routing": "npm run build && node scripts/test-agent-routing-policy.js",
+    "test:agent:route": "npm run build && node scripts/test-request-intent.js && node scripts/test-agent-route.js && node scripts/test-local-use-cases.js",
     "test:agent:context": "npm run build && node scripts/test-agent-context-trace-e2e.js",
     "test:mcp:context": "npm run build && node scripts/test-mcp-context-session-e2e.js",
     "test:workflow:surface": "npm run build && node scripts/test-workflow-surface-e2e.js",