vigthoria-cli 1.10.47 → 1.10.48

package/dist/utils/persona.js

@@ -1,8 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizePersonaMode = normalizePersonaMode;
-exports.isToneDownPrompt = isToneDownPrompt;
-exports.buildPersonaOverlay = buildPersonaOverlay;
 const WIENER_GRANT_PROMPT = [
     'Optional persona overlay: Wiener Grantler mode.',
     'You remain Vigthoria: technically precise, helpful, safe, and comprehensive.',
@@ -18,7 +13,7 @@ const TONE_DOWN_PROMPT = [
     'Tone-down rule active: this request appears safety-sensitive, destructive, auth/billing-related, security-related, legal/medical/financial, or production-critical.',
     'Use only a very light flavor line if appropriate, then prioritize plain clarity, caution, and exact steps.',
 ].join('\n');
-function normalizePersonaMode(value) {
+export function normalizePersonaMode(value) {
     const normalized = String(value || '').trim().toLowerCase().replace(/_/g, '-');
     if (!normalized || normalized === 'default' || normalized === 'off' || normalized === 'none')
         return 'default';
@@ -26,10 +21,10 @@ function normalizePersonaMode(value) {
         return 'wiener_grant';
     return null;
 }
-function isToneDownPrompt(prompt) {
+export function isToneDownPrompt(prompt) {
     return /\b(delete|drop|destroy|wipe|rm\s+-rf|format|credential|secret|token|auth|login|billing|payment|wallet|security|vulnerability|exploit|incident|production|prod|deploy|legal|medical|financial|bank|tax)\b/i.test(prompt);
 }
-function buildPersonaOverlay(mode, prompt = '') {
+export function buildPersonaOverlay(mode, prompt = '') {
     if (mode !== 'wiener_grant')
         return '';
     const parts = [WIENER_GRANT_PROMPT];

package/dist/utils/post-write-validator.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Vigthoria CLI — Post-Write Validator / Self-Healing Layer
  *
@@ -9,18 +8,12 @@
  *
  * Used by runSelfHealingCycle in api.ts to send targeted correction prompts.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runPostWriteValidation = runPostWriteValidation;
-exports.formatValidationErrors = formatValidationErrors;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 function commandExists(cmd, args = ['--version']) {
     try {
-        (0, node_child_process_1.execFileSync)(cmd, args, { stdio: 'pipe', timeout: 4000, windowsHide: true });
+        execFileSync(cmd, args, { stdio: 'pipe', timeout: 4000, windowsHide: true });
         return true;
     }
     catch {
@@ -28,23 +21,23 @@ function commandExists(cmd, args = ['--version']) {
     }
 }
 function hasTsConfig(dir) {
-    return node_fs_1.default.existsSync(node_path_1.default.join(dir, 'tsconfig.json'));
+    return fs.existsSync(path.join(dir, 'tsconfig.json'));
 }
 /**
  * Resolve the best available tsc binary for the project.
  * Prefers local node_modules/.bin/tsc over npx to avoid network fetches.
  */
 function resolveTscBin(workspacePath) {
-    const localTsc = node_path_1.default.join(workspacePath, 'node_modules', '.bin', 'tsc');
-    if (node_fs_1.default.existsSync(localTsc))
+    const localTsc = path.join(workspacePath, 'node_modules', '.bin', 'tsc');
+    if (fs.existsSync(localTsc))
         return { cmd: localTsc, args: ["--noEmit", "--skipLibCheck"] };
     try {
-        (0, node_child_process_1.execFileSync)("npx", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
+        execFileSync("npx", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
         return { cmd: "npx", args: ["tsc", "--noEmit", "--skipLibCheck"] };
     }
     catch { /* npx not available */ }
     try {
-        (0, node_child_process_1.execFileSync)("tsc", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
+        execFileSync("tsc", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
         return { cmd: "tsc", args: ["--noEmit", "--skipLibCheck"] };
     }
     catch { /* tsc not available */ }
@@ -52,10 +45,10 @@ function resolveTscBin(workspacePath) {
 }
 function hasRealTestScript(dir) {
     try {
-        const pkgPath = node_path_1.default.join(dir, 'package.json');
-        if (!node_fs_1.default.existsSync(pkgPath))
+        const pkgPath = path.join(dir, 'package.json');
+        if (!fs.existsSync(pkgPath))
             return false;
-        const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
         const script = pkg.scripts?.test ?? '';
         return typeof script === 'string' && script.length > 0
             && !script.startsWith('echo "Error: no test specified"');
@@ -68,8 +61,8 @@ function hasRealTestScript(dir) {
  * Run post-write validation in the project directory.
  * Each check is time-bounded to avoid blocking the CLI.
  */
-async function runPostWriteValidation(workspacePath) {
-    if (!workspacePath || !node_fs_1.default.existsSync(workspacePath))
+export async function runPostWriteValidation(workspacePath) {
+    if (!workspacePath || !fs.existsSync(workspacePath))
         return [];
     const results = [];
     const opts = { cwd: workspacePath, stdio: 'pipe', windowsHide: true };
@@ -77,7 +70,7 @@ async function runPostWriteValidation(workspacePath) {
     const tscBin = hasTsConfig(workspacePath) ? resolveTscBin(workspacePath) : null;
     if (tscBin) {
         try {
-            (0, node_child_process_1.execFileSync)(tscBin.cmd, tscBin.args, { ...opts, timeout: 45_000 });
+            execFileSync(tscBin.cmd, tscBin.args, { ...opts, timeout: 45_000 });
             results.push({ ran: true, tool: 'tsc', passed: true, output: '' });
         }
         catch (err) {
@@ -88,7 +81,7 @@ async function runPostWriteValidation(workspacePath) {
     // 2. npm test
     if (hasRealTestScript(workspacePath) && commandExists('npm')) {
         try {
-            (0, node_child_process_1.execFileSync)('npm', ['test', '--', '--passWithNoTests'], { ...opts, timeout: 90_000 });
+            execFileSync('npm', ['test', '--', '--passWithNoTests'], { ...opts, timeout: 90_000 });
             results.push({ ran: true, tool: 'npm test', passed: true, output: '' });
         }
         catch (err) {
@@ -97,13 +90,13 @@ async function runPostWriteValidation(workspacePath) {
         }
     }
     // 3. Python syntax check
-    const hasPy = node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'requirements.txt'))
-        || node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'setup.py'))
-        || node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'pyproject.toml'));
+    const hasPy = fs.existsSync(path.join(workspacePath, 'requirements.txt'))
+        || fs.existsSync(path.join(workspacePath, 'setup.py'))
+        || fs.existsSync(path.join(workspacePath, 'pyproject.toml'));
     if (hasPy && commandExists('python3', ['-c', 'import ast'])) {
         const pyFiles = [];
         try {
-            const entries = node_fs_1.default.readdirSync(workspacePath, { withFileTypes: true });
+            const entries = fs.readdirSync(workspacePath, { withFileTypes: true });
             for (const e of entries) {
                 if (e.isFile() && e.name.endsWith('.py'))
                     pyFiles.push(e.name);
@@ -114,7 +107,7 @@ async function runPostWriteValidation(workspacePath) {
         let pyOut = '';
         for (const pyFile of pyFiles.slice(0, 20)) {
             try {
-                (0, node_child_process_1.execFileSync)('python3', ['-m', 'py_compile', pyFile], { ...opts, timeout: 10_000 });
+                execFileSync('python3', ['-m', 'py_compile', pyFile], { ...opts, timeout: 10_000 });
             }
             catch (err) {
                 pyPassed = false;
@@ -130,7 +123,7 @@ async function runPostWriteValidation(workspacePath) {
 /**
  * Build a clear error summary string from failed validation results.
  */
-function formatValidationErrors(results) {
+export function formatValidationErrors(results) {
     return results
         .filter((r) => r.ran && !r.passed)
         .map((r) => `[${r.tool}]\n${r.output.trim()}`)

package/dist/utils/project-memory.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Vigthoria Project Memory Service
  *
@@ -6,14 +5,9 @@
  * compact facts that can be retrieved for follow-up prompts without replaying
  * full chat history or noisy tool traces.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectMemoryService = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_crypto_1 = require("node:crypto");
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
 const MAX_ITEMS = 240;
 const MAX_TEXT_LENGTH = 320;
 const MAX_CONTEXT_ITEMS = 14;
@@ -35,7 +29,7 @@ function clampText(value, max = MAX_TEXT_LENGTH) {
     return normalized.length > max ? `${normalized.slice(0, max - 3)}...` : normalized;
 }
 function slugHash(value) {
-    return (0, node_crypto_1.createHash)('sha1').update(value).digest('hex').slice(0, 12);
+    return createHash('sha1').update(value).digest('hex').slice(0, 12);
 }
 function tokenize(value) {
     return Array.from(new Set(String(value || '')
@@ -65,22 +59,22 @@ function inferTags(text) {
         tags.add('validation');
     return Array.from(tags).slice(0, 8);
 }
-class ProjectMemoryService {
+export class ProjectMemoryService {
     workspacePath;
     memoryDir;
     brainPath;
     constructor(workspacePath = process.cwd()) {
-        this.workspacePath = node_path_1.default.resolve(workspacePath || process.cwd());
-        this.memoryDir = node_path_1.default.join(this.workspacePath, '.vigthoria', 'memory');
-        this.brainPath = node_path_1.default.join(this.memoryDir, 'brain.json');
+        this.workspacePath = path.resolve(workspacePath || process.cwd());
+        this.memoryDir = path.join(this.workspacePath, '.vigthoria', 'memory');
+        this.brainPath = path.join(this.memoryDir, 'brain.json');
     }
     getMemoryDir() {
         return this.memoryDir;
     }
     loadBrain() {
         try {
-            if (node_fs_1.default.existsSync(this.brainPath)) {
-                const parsed = JSON.parse(node_fs_1.default.readFileSync(this.brainPath, 'utf8'));
+            if (fs.existsSync(this.brainPath)) {
+                const parsed = JSON.parse(fs.readFileSync(this.brainPath, 'utf8'));
                 if (parsed && parsed.version === 1 && Array.isArray(parsed.items)) {
                     return parsed;
                 }
@@ -91,21 +85,21 @@ class ProjectMemoryService {
         }
         return {
             version: 1,
-            workspaceName: node_path_1.default.basename(this.workspacePath),
+            workspaceName: path.basename(this.workspacePath),
             updatedAt: nowIso(),
             items: [],
         };
     }
     saveBrain(brain) {
         try {
-            node_fs_1.default.mkdirSync(this.memoryDir, { recursive: true });
+            fs.mkdirSync(this.memoryDir, { recursive: true });
             const normalized = {
                 ...brain,
-                workspaceName: brain.workspaceName || node_path_1.default.basename(this.workspacePath),
+                workspaceName: brain.workspaceName || path.basename(this.workspacePath),
                 updatedAt: nowIso(),
                 items: this.dedupeAndTrim(brain.items || []),
             };
-            node_fs_1.default.writeFileSync(this.brainPath, JSON.stringify(normalized, null, 2) + '\n', 'utf8');
+            fs.writeFileSync(this.brainPath, JSON.stringify(normalized, null, 2) + '\n', 'utf8');
             this.writeMarkdownViews(normalized);
         }
         catch {
@@ -276,10 +270,10 @@ class ProjectMemoryService {
                 continue;
             const heading = this.headingForType(type);
             const lines = [`# ${heading}`, '', ...items.map((item) => `- ${item.text}`)];
-            node_fs_1.default.writeFileSync(node_path_1.default.join(this.memoryDir, `${type}s.md`), lines.join('\n') + '\n', 'utf8');
+            fs.writeFileSync(path.join(this.memoryDir, `${type}s.md`), lines.join('\n') + '\n', 'utf8');
             allLines.push(`## ${heading}`, '', ...items.slice(-40).map((item) => `- ${item.text}`), '');
         }
-        node_fs_1.default.writeFileSync(node_path_1.default.join(this.memoryDir, 'README.md'), allLines.join('\n').trimEnd() + '\n', 'utf8');
+        fs.writeFileSync(path.join(this.memoryDir, 'README.md'), allLines.join('\n').trimEnd() + '\n', 'utf8');
     }
     headingForType(type) {
         switch (type) {
@@ -293,4 +287,3 @@ class ProjectMemoryService {
         }
     }
 }
-exports.ProjectMemoryService = ProjectMemoryService;

package/dist/utils/session.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Session Manager - Persist and resume conversations
+ * Similar to Vigthoria's session persistence
+ */
+import { ChatMessage } from './api.js';
+export type AuthState = {
+    token: string | null;
+    expiresAt: number | null;
+    isValid: boolean;
+};
+export type CliError = {
+    code: string;
+    message: string;
+    details?: any;
+    isCritical: boolean;
+};
+/**
+ * Validate persisted authentication state without assuming any field is present.
+ *
+ * Production hygiene: by default this helper is SILENT.  Earlier revisions
+ * wrote ``console.warn`` for every missing-token branch, which polluted
+ * stderr on PowerShell (NativeCommandError styling) and surfaced as noise
+ * on first-run installs.  Pass ``{ silent: false }`` only when the caller
+ * actually wants the warning visible.
+ */
+export declare function validateSession(session: AuthState, options?: {
+    silent?: boolean;
+}): boolean;
+/**
+ * Load persisted authentication state and normalize nullable token fields safely.
+ *
+ * Production behaviour: first-run users (no session file yet) get a clean
+ * ``{ token: null, expiresAt: null, isValid: false }`` instead of an
+ * exception.  Callers that need a hard failure can inspect ``isValid``.
+ */
+export declare function loadSession(): Promise<AuthState>;
+export interface Session {
+    id: string;
+    name: string;
+    project: string;
+    model: string;
+    messages: ChatMessage[];
+    memorySummary?: string;
+    compactedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    agentMode: boolean;
+    operatorMode?: boolean;
+}
+export declare class SessionManager {
+    private sessionsDir;
+    private readonly compactThreshold;
+    private readonly retainRecentMessages;
+    /** Keep at most this many session files on disk per CLI install. */
+    private readonly maxRetainedSessions;
+    /** Sessions older than this are pruned (90 days). */
+    private readonly retentionWindowMs;
+    /** Avoid running prune on every save — at most once per CLI process. */
+    private prunedThisProcess;
+    constructor();
+    private ensureDir;
+    /**
+     * Prune sessions older than the retention window AND cap the number of
+     * retained files.  This is best-effort: any unreadable file is treated
+     * as stale and removed.  Pruning is bounded to once per process.
+     */
+    private pruneIfNeeded;
+    /**
+     * Generate unique session ID
+     */
+    private generateId;
+    /**
+     * Create a new session
+     */
+    create(project: string, model: string, agentMode?: boolean, operatorMode?: boolean): Session;
+    /**
+     * Save session to disk — atomic + 0600 mode so transcripts cannot be
+     * read by other local users on a shared POSIX host.
+     */
+    save(session: Session): void;
+    /**
+     * Load session by ID
+     */
+    load(id: string): Session | null;
+    /**
+     * Get the most recent session for a project
+     */
+    getLatest(project: string): Session | null;
+    /**
+     * List all sessions (metadata only) — corrupt or unreadable files are
+     * skipped silently unless VIGTHORIA_DEBUG=1.
+     */
+    list(): Omit<Session, 'messages'>[];
+    /**
+     * Delete a session
+     */
+    delete(id: string): boolean;
+    /**
+     * Clear all sessions
+     */
+    clearAll(): number;
+    /**
+     * Add message to session
+     */
+    addMessage(session: Session, message: ChatMessage): void;
+    compactInMemory(session: Session): Session;
+    buildMemoryContext(session: Session | null): string;
+    private compactSession;
+    private isPersistentSystemMessage;
+    private mergePersistentAndRecent;
+    private mergeSummaries;
+    private summarizeMessages;
+    private normalizeMessageContent;
+    /**
+     * Get session summary for display
+     */
+    getSummary(session: Session): string;
+}