vigthoria-cli 1.13.20 → 1.13.23

package/dist/utils/cli-state.js

@@ -14,28 +14,50 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { createHash, randomUUID } from 'crypto';
+import { DurableJsonStore } from './durable-json.js';
 const STATE_DIR = path.join(os.homedir(), '.vigthoria');
 const STATE_FILE = path.join(STATE_DIR, 'cli-state.json');
 /** 24h is plenty for an update-check ping. */
 export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
 /** 60s gateway-preflight cache so back-to-back CLI invocations stay fast. */
 export const GATEWAY_PREFLIGHT_TTL_MS = 60 * 1000;
-function readStateUnchecked() {
-    try {
-        if (!fs.existsSync(STATE_FILE)) {
-            return {};
-        }
-        const text = fs.readFileSync(STATE_FILE, 'utf8');
-        if (!text.trim()) {
+function isCliState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const state = value;
+    if (state.updateCheck !== undefined && (!state.updateCheck || typeof state.updateCheck.checkedAt !== 'number' || typeof state.updateCheck.latestVersion !== 'string'))
+        return false;
+    if (state.lastSeenVersion !== undefined && typeof state.lastSeenVersion !== 'string')
+        return false;
+    if (state.gatewayPreflight !== undefined && (!state.gatewayPreflight || typeof state.gatewayPreflight !== 'object' || Array.isArray(state.gatewayPreflight)))
+        return false;
+    return true;
+}
+const stateStore = new DurableJsonStore({
+    filePath: STATE_FILE,
+    schemaVersion: 2,
+    defaultValue: () => ({}),
+    validate: isCliState,
+    migrate: (value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
             return {};
+        const legacy = value;
+        // A legacy preflight boolean has no credential, endpoint, or capability
+        // audience and is intentionally invalidated during migration.
+        const migrated = {};
+        if (legacy.updateCheck && typeof legacy.updateCheck === 'object') {
+            const entry = legacy.updateCheck;
+            if (entry && typeof entry.checkedAt === 'number' && typeof entry.latestVersion === 'string')
+                migrated.updateCheck = entry;
         }
-        const parsed = JSON.parse(text);
-        return parsed && typeof parsed === 'object' ? parsed : {};
-    }
-    catch {
-        // Corrupt state file should never crash the CLI — treat as empty.
-        return {};
-    }
+        if (typeof legacy.lastSeenVersion === 'string')
+            migrated.lastSeenVersion = legacy.lastSeenVersion;
+        return migrated;
+    },
+});
+function readStateUnchecked() {
+    return stateStore.read();
 }
 export function ensureStateDir() {
     try {
@@ -74,8 +96,15 @@ export function atomicWriteJson(targetPath, value, mode = 0o600) {
             fs.mkdirSync(parent, { recursive: true });
     }
     catch { /* ignore */ }
-    const tmpPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(tmpPath, JSON.stringify(value, null, 2), 'utf8');
+    const tmpPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+    const descriptor = fs.openSync(tmpPath, 'wx', mode);
+    try {
+        fs.writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
     if (process.platform !== 'win32') {
         try {
             fs.chmodSync(tmpPath, mode);
@@ -88,7 +117,7 @@ export function loadCliState() {
     return readStateUnchecked();
 }
 export function saveCliState(state) {
-    atomicWriteJson(STATE_FILE, state);
+    stateStore.write(state);
 }
 export function getCliStateFile() {
     return STATE_FILE;
@@ -129,39 +158,73 @@ export function readCachedLatestVersion(maxAgeMs = UPDATE_CHECK_TTL_MS) {
     return entry.latestVersion;
 }
 export function writeCachedLatestVersion(latestVersion, notifiedFor) {
-    try {
-        const state = readStateUnchecked();
-        state.updateCheck = {
+    stateStore.update((state) => ({
+        ...state,
+        updateCheck: {
             checkedAt: Date.now(),
             latestVersion,
             notifiedFor: notifiedFor || state.updateCheck?.notifiedFor,
-        };
-        saveCliState(state);
-    }
-    catch {
-        // Caching is a nice-to-have, never block CLI on write failure.
-    }
+        },
+    }));
+}
+function normalizeEndpoint(endpoint) {
+    const parsed = new URL(String(endpoint));
+    parsed.hash = '';
+    parsed.search = '';
+    parsed.hostname = parsed.hostname.toLowerCase();
+    parsed.pathname = parsed.pathname.replace(/\/+$/, '') || '/';
+    return parsed.toString().replace(/\/$/, '');
 }
-export function readGatewayPreflightCache(maxAgeMs = GATEWAY_PREFLIGHT_TTL_MS) {
+function fingerprint(value) {
+    const serialized = typeof value === 'string' ? value : JSON.stringify(value ?? null);
+    return createHash('sha256').update(serialized).digest('hex');
+}
+export function createGatewayPreflightCacheKey(input) {
+    const endpoint = normalizeEndpoint(input.endpoint);
+    const credentialFingerprint = fingerprint(String(input.credential || ''));
+    const capability = String(input.capability || '').trim().toLowerCase();
+    if (!capability)
+        throw new Error('Gateway preflight capability is required.');
+    const configurationFingerprint = fingerprint(input.relevantConfiguration ?? null);
+    return {
+        id: fingerprint({ endpoint, credentialFingerprint, capability, configurationFingerprint }),
+        endpoint,
+        credentialFingerprint,
+        capability,
+        configurationFingerprint,
+    };
+}
+export function readGatewayPreflightCache(key, maxAgeMs = GATEWAY_PREFLIGHT_TTL_MS) {
     const state = readStateUnchecked();
-    const entry = state.gatewayPreflight;
+    const entry = state.gatewayPreflight?.[key.id];
     if (!entry || typeof entry.checkedAt !== 'number' || typeof entry.valid !== 'boolean') {
         return null;
     }
+    if (entry.endpoint !== key.endpoint
+        || entry.credentialFingerprint !== key.credentialFingerprint
+        || entry.capability !== key.capability
+        || entry.configurationFingerprint !== key.configurationFingerprint)
+        return null;
     if (Date.now() - entry.checkedAt > maxAgeMs) {
         return null;
     }
     return entry.valid;
 }
-export function writeGatewayPreflightCache(valid) {
-    try {
-        const state = readStateUnchecked();
-        state.gatewayPreflight = { checkedAt: Date.now(), valid };
-        saveCliState(state);
-    }
-    catch {
-        // Best-effort.
-    }
+export function writeGatewayPreflightCache(key, valid) {
+    stateStore.update((state) => ({
+        ...state,
+        gatewayPreflight: {
+            ...(state.gatewayPreflight || {}),
+            [key.id]: {
+                checkedAt: Date.now(),
+                valid,
+                endpoint: key.endpoint,
+                credentialFingerprint: key.credentialFingerprint,
+                capability: key.capability,
+                configurationFingerprint: key.configurationFingerprint,
+            },
+        },
+    }));
 }
 /**
  * Invalidate any cached gateway-preflight result.  Must be called on
@@ -170,16 +233,11 @@ export function writeGatewayPreflightCache(valid) {
  * command run right after a fresh, successful login.
  */
 export function clearGatewayPreflightCache() {
-    try {
-        const state = readStateUnchecked();
-        if (state.gatewayPreflight) {
-            delete state.gatewayPreflight;
-            saveCliState(state);
-        }
-    }
-    catch {
-        // Best-effort.
-    }
+    stateStore.update((state) => {
+        const next = { ...state };
+        delete next.gatewayPreflight;
+        return next;
+    });
 }
 /**
  * Validate an npm package spec used by `vigthoria update --from <spec>`.

package/dist/utils/code-operations-service.d.ts

@@ -0,0 +1,104 @@
+export type CodeCompletionPort = (systemPrompt: string, userPrompt: string, model?: string, maxTokens?: number) => Promise<string>;
+export declare class CodeOperationsService {
+    private readonly complete;
+    constructor(complete: CodeCompletionPort);
+    private chatComplete;
+    generateCode(prompt: string, language: string, model: string): Promise<string>;
+    /**
+     * Ensure code has balanced curly braces by appending missing closing braces.
+     */
+    private ensureBalancedBraces;
+    /**
+     * Quick JS/TS syntax validation using Node's built-in parser.
+     * Returns true if the code parses without errors.
+     */
+    private validateJsSyntax;
+    /**
+     * Extract the first complete function/class from code.
+     * Used as last-resort when the model keeps over-producing.
+     */
+    private extractFirstFunction;
+    /**
+     * Detect if code is excessively over-engineered for a short prompt.
+     * E.g. a "multiply function" request producing 20+ lines.
+     */
+    private codeIsOverEngineered;
+    /**
+     * Detect if generated code contains DOM/HTML pollution inappropriate
+     * for a pure programming language like JavaScript, Python, etc.
+     */
+    private codeContainsDomPollution;
+    /**
+     * Strip DOM pollution from generated code, keeping only the pure logic.
+     * Used as last-resort fallback when the model repeatedly ignores constraints.
+     */
+    private stripDomPollution;
+    generateProject(prompt: string, projectType: string, model: string): Promise<{
+        code: string;
+        plan?: any;
+        quality?: {
+            lineCount: number;
+            score: number;
+            checks: {
+                hasAnimations: boolean;
+                hasNeonEffects: boolean;
+                hasResponsive: boolean;
+                hasFontAwesome: boolean;
+                hasGoogleFonts: boolean;
+            };
+        };
+    }>;
+    explainCode(code: string, language: string): Promise<string>;
+    reviewCode(code: string, language: string): Promise<{
+        score: number;
+        issues: {
+            type: string;
+            line: number;
+            message: string;
+            severity: string;
+        }[];
+        suggestions: string[];
+    }>;
+    /**
+     * Lightweight client-side heuristic scan: catches common code smells
+     * AND logic/arithmetic bugs so review never returns "score 30, no issues".
+     */
+    heuristicCodeIssues(code: string, _language: string): {
+        type: string;
+        line: number;
+        message: string;
+        severity: string;
+    }[];
+    fixCode(code: string, language: string, fixType: string): Promise<{
+        fixed: string;
+        changes: {
+            line: number;
+            before: string;
+            after: string;
+            reason: string;
+        }[];
+    }>;
+    /**
+     * Compute a semantic diff between original and fixed code using
+     * Longest Common Subsequence (LCS) to avoid the line-shift inflation
+     * bug where inserting one line flags all subsequent lines as changed.
+     */
+    private computeSemanticDiff;
+    /**
+     * Lightweight client-side syntax error detection.
+     * Returns a human-readable description of obvious errors, or empty string.
+     */
+    detectSyntaxErrors(code: string, language: string): string;
+    /**
+     * Strip comment lines that the model added during a fix but were not
+     * present in the original code.  Used for syntax-only fixes where the
+     * model tends to annotate its changes with "// Fixed ..." comments.
+     */
+    stripInjectedComments(original: string, fixed: string, language: string): string;
+    /**
+     * Ensure the fixed code hasn't lost closing delimiters relative to the
+     * original.  Counts {, }, (, ), [, ] outside strings/comments and if
+     * the fix has fewer closers than the original, appends the missing ones.
+     */
+    repairBracketBalance(original: string, fixed: string): string;
+}