@nan0web/ui 1.12.2 → 3.1.0

package/src/domain/app/JsIntentAuditor.js

@@ -0,0 +1,145 @@
+import { AuditorModel } from '@nan0web/inspect/domain/AuditorModel'
+import { result, show, progress } from '../../core/Intent.js'
+import { IntentAuditor } from './IntentAuditor.js'
+
+/**
+ * JsIntentAuditor — Specialized auditor for JS/TS output hygiene.
+ */
+export class JsIntentAuditor extends AuditorModel {
+	/** @type {string[]} Directories to ignore during scanning */
+	static IGNORE_DIRS = ['node_modules', '.git', '.venv', '.datasets', 'dist', 'build', 'types', 'play', 'test']
+
+	/**
+	 * Checks if a directory or file should be ignored.
+	 * @param {string} name
+	 * @returns {boolean}
+	 */
+	static isIgnored(name) {
+		return name.startsWith('.') || JsIntentAuditor.IGNORE_DIRS.includes(name)
+	}
+
+	/**
+	 * Run the JS-specific intent audit.
+	 * @returns {AsyncGenerator<import('@nan0web/ui').Intent, import('@nan0web/ui').ResultIntent, any>}
+	 */
+	async *run() {
+		const { t } = /** @type {any} */ (this)._
+		yield show(t(IntentAuditor.UI.starting, { dir: /** @type {any} */ (this).dir }))
+
+		const fsDb = /** @type {any} */ (this)._.db
+		if (!fsDb) {
+			yield show(t(IntentAuditor.UI.errorDb), 'error')
+			return result({ success: false })
+		}
+
+		const files = []
+		const targetDir = fsDb.resolveSync(/** @type {any} */ (this).dir)
+
+		try {
+			for await (const entry of fsDb.browse(targetDir, { depth: Infinity })) {
+				if (JsIntentAuditor.isIgnored(entry.name)) continue
+				
+				if (
+					entry.isFile && 
+					/\.(js|ts|jsx|tsx)$/.test(entry.name) && 
+					!entry.name.endsWith('.test.js') &&
+					!entry.name.endsWith('.story.js') &&
+					!entry.path.includes('/test/') &&
+					!entry.path.includes('/play/')
+				) {
+					files.push(entry.path)
+				}
+			}
+		} catch (e) {
+			// Directory might be missing
+		}
+
+		if (files.length === 0) {
+			yield show(t(IntentAuditor.UI.doneSuccess, {}), 'success')
+			return result({ success: true })
+		}
+
+		let hasErrors = false
+		const allErrors = []
+
+		for (const file of files) {
+			const displayFile = file.startsWith('@app/') ? file.slice(5) : file
+			const content = await fsDb.fetch(file)
+			const contentString = typeof content === 'string' ? content : JSON.stringify(content)
+
+			const fileErrors = JsIntentAuditor.inspectFileContent(contentString, t)
+			if (fileErrors.length > 0) {
+				const errorMessages = fileErrors.join('; ')
+				yield show(
+					t(IntentAuditor.UI.auditFailed, { file: displayFile, errors: errorMessages }),
+					'error',
+				)
+				allErrors.push(...fileErrors.map((e) => ({ file: displayFile, error: e })))
+				hasErrors = true
+			} else {
+				yield progress(t(IntentAuditor.UI.auditPassed, { file: displayFile }))
+			}
+		}
+
+		if (hasErrors) {
+			yield show(t(IntentAuditor.UI.doneErrors, {}), 'error')
+			return result({ success: false, errors: allErrors })
+		}
+
+		yield show(t(IntentAuditor.UI.doneSuccess, {}), 'success')
+		return result({ success: true })
+	}
+
+	/**
+	 * Inspects file content for console.* or process.* writes.
+	 * @param {string} content Content of the file.
+	 * @param {import('@nan0web/i18n').TFunction} t Translate function.
+	 * @returns {string[]} List of error messages.
+	 */
+	static inspectFileContent(content, t) {
+		const errors = []
+		const lines = content.split('\n')
+
+		lines.forEach((lineText, index) => {
+			const lineNum = index + 1
+			const trimmed = lineText.trim()
+
+			// Skip comments
+			if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*')) {
+				return
+			}
+
+			// 1. Thorough console.* statement scan (including table, trace, etc.)
+			const consoleMatch = trimmed.match(/console\.(log|error|warn|info|debug|dir|table|trace|assert)\(/)
+			if (consoleMatch) {
+				const codeBeforeComment = trimmed.split('//')[0]
+				if (codeBeforeComment.includes(consoleMatch[0])) {
+					errors.push(
+						t(IntentAuditor.UI.errorConsoleLeak, {
+							line: lineNum,
+							match: consoleMatch[0] + '...',
+						}),
+					)
+				}
+			}
+
+			// 2. process.stdout/stderr write scan
+			const processMatch = trimmed.match(/process\.(stdout|stderr)\.write\(/)
+			if (processMatch) {
+				const codeBeforeComment = trimmed.split('//')[0]
+				if (codeBeforeComment.includes(processMatch[0])) {
+					errors.push(
+						t(IntentAuditor.UI.errorProcessLeak, {
+							line: lineNum,
+							match: processMatch[0] + '...',
+						}),
+					)
+				}
+			}
+		})
+
+		return errors
+	}
+}
+
+export default JsIntentAuditor

package/src/domain/app/PyIntentAuditor.js

@@ -0,0 +1,144 @@
+import { AuditorModel } from '@nan0web/inspect/domain/AuditorModel'
+import { result, show, progress } from '../../core/Intent.js'
+import { IntentAuditor } from './IntentAuditor.js'
+
+/**
+ * PyIntentAuditor — Specialized auditor for Python output hygiene.
+ */
+export class PyIntentAuditor extends AuditorModel {
+	/** @type {string[]} Directories to ignore during scanning */
+	static IGNORE_DIRS = ['node_modules', '.git', '.venv', '.datasets', 'dist', 'build', 'types', 'play', 'test', 'tests']
+
+	/**
+	 * Checks if a directory or file should be ignored.
+	 * @param {string} name
+	 * @returns {boolean}
+	 */
+	static isIgnored(name) {
+		return name.startsWith('.') || PyIntentAuditor.IGNORE_DIRS.includes(name)
+	}
+
+	/**
+	 * Run the Python-specific intent audit.
+	 * @returns {AsyncGenerator<import('@nan0web/ui').Intent, import('@nan0web/ui').ResultIntent, any>}
+	 */
+	async *run() {
+		const { t } = /** @type {any} */ (this)._
+		yield show(t(IntentAuditor.UI.starting, { dir: /** @type {any} */ (this).dir }))
+
+		const fsDb = /** @type {any} */ (this)._.db
+		if (!fsDb) {
+			yield show(t(IntentAuditor.UI.errorDb), 'error')
+			return result({ success: false })
+		}
+
+		const files = []
+		const targetDir = fsDb.resolveSync(/** @type {any} */ (this).dir)
+
+		try {
+			for await (const entry of fsDb.browse(targetDir, { depth: Infinity })) {
+				if (PyIntentAuditor.isIgnored(entry.name)) continue
+				
+				if (
+					entry.isFile && 
+					/\.py$/.test(entry.name) && 
+					!entry.name.startsWith('test_') &&
+					!entry.name.endsWith('_test.py') &&
+					!entry.path.includes('/tests/')
+				) {
+					files.push(entry.path)
+				}
+			}
+		} catch (e) {
+			// Directory might be missing
+		}
+
+		if (files.length === 0) {
+			yield show(t(IntentAuditor.UI.doneSuccess, {}), 'success')
+			return result({ success: true })
+		}
+
+		let hasErrors = false
+		const allErrors = []
+
+		for (const file of files) {
+			const displayFile = file.startsWith('@app/') ? file.slice(5) : file
+			const content = await fsDb.fetch(file)
+			const contentString = typeof content === 'string' ? content : JSON.stringify(content)
+
+			const fileErrors = PyIntentAuditor.inspectFileContent(contentString, t)
+			if (fileErrors.length > 0) {
+				const errorMessages = fileErrors.join('; ')
+				yield show(
+					t(IntentAuditor.UI.auditFailed, { file: displayFile, errors: errorMessages }),
+					'error',
+				)
+				allErrors.push(...fileErrors.map((e) => ({ file: displayFile, error: e })))
+				hasErrors = true
+			} else {
+				yield progress(t(IntentAuditor.UI.auditPassed, { file: displayFile }))
+			}
+		}
+
+		if (hasErrors) {
+			yield show(t(IntentAuditor.UI.doneErrors, {}), 'error')
+			return result({ success: false, errors: allErrors })
+		}
+
+		yield show(t(IntentAuditor.UI.doneSuccess, {}), 'success')
+		return result({ success: true })
+	}
+
+	/**
+	 * Inspects Python file content for print or sys.stdout/stderr writes.
+	 * @param {string} content Content of the file.
+	 * @param {import('@nan0web/i18n').TFunction} t Translate function.
+	 * @returns {string[]} List of error messages.
+	 */
+	static inspectFileContent(content, t) {
+		const errors = []
+		const lines = content.split('\n')
+
+		lines.forEach((lineText, index) => {
+			const lineNum = index + 1
+			const trimmed = lineText.trim()
+
+			// Python Comment skip
+			if (trimmed.startsWith('#')) {
+				return
+			}
+
+			// 1. Python print statement check
+			const printMatch = trimmed.match(/\bprint\(/)
+			if (printMatch) {
+				const codeBeforeComment = trimmed.split('#')[0]
+				if (codeBeforeComment.includes(printMatch[0])) {
+					errors.push(
+						t(IntentAuditor.UI.errorPrintLeak, {
+							line: lineNum,
+							match: 'print(...)',
+						}),
+					)
+				}
+			}
+
+			// 2. sys.stdout/stderr write check
+			const sysMatch = trimmed.match(/\bsys\.(stdout|stderr)\.write\(/)
+			if (sysMatch) {
+				const codeBeforeComment = trimmed.split('#')[0]
+				if (codeBeforeComment.includes(sysMatch[0])) {
+					errors.push(
+						t(IntentAuditor.UI.errorSysWriteLeak, {
+							line: lineNum,
+							match: sysMatch[0] + '...',
+						}),
+					)
+				}
+			}
+		})
+
+		return errors
+	}
+}
+
+export default PyIntentAuditor

package/src/domain/app/SnapshotAuditor.js

@@ -1,15 +1,14 @@
 import { NaN0 } from '@nan0web/types'
-import { AuditorModel } from '@nan0web/inspect'
-import { progress, result, show } from '../../core/Intent.js'
+import { AuditorModel } from '@nan0web/inspect/domain/AuditorModel'
+
+import { result, show, progress } from '../../core/Intent.js'
 
 /**
  * SnapshotAuditor — Zero-Hallucination Snapshot Validation (Model-as-Schema v2).
  * Parses snapshots without evaluating the app logic and detects artifacts.
- *
- * @extends {AuditorModel}
  */
 export class SnapshotAuditor extends AuditorModel {
-	static alias = 'audit'
+	static alias = 'snapshots'
 
 	static dir = {
 		type: 'string',
@@ -24,7 +23,6 @@ export class SnapshotAuditor extends AuditorModel {
 		default: 'data',
 	}
 
-	/** @type {Object<string, string>} Messages for UI */
 	static UI = {
 		title: 'Snapshot Auditor',
 		description: 'Validates UI snapshots against hallucinations and localization leaks.',
@@ -36,6 +34,7 @@ export class SnapshotAuditor extends AuditorModel {
 		auditPassed: 'Audit passed: {file}',
 		auditFailed: 'Audit failed for {file}: {errors}',
 
+		errorDb: 'Database not provided to auditor',
 		errorGlitch: 'Filename "{filename}" has multiple consecutive separators (glitch detected).',
 		errorShort: 'Filename "{filename}" is too short.',
 		errorSyntax: 'Syntax Error: Failed to parse NaN0 file. {msg}',
@@ -56,7 +55,24 @@ export class SnapshotAuditor extends AuditorModel {
 	static ARTIFACTS = ['[object Object]', 'undefined', 'NaN']
 
 	/** @type {string[]} Words to ignore across all languages */
-	static EXEMPT_WORDS = ['true', 'false', 'value', 'max', 'min', 'step', 'open', 'first', 'what', 'how', 'start', 'code', 'successfully', 'enter', 'with', 'system']
+	static EXEMPT_WORDS = [
+		'true',
+		'false',
+		'value',
+		'max',
+		'min',
+		'step',
+		'open',
+		'first',
+		'what',
+		'how',
+		'start',
+		'code',
+		'successfully',
+		'enter',
+		'with',
+		'system',
+	]
 
 	/** @type {RegExp} Pattern for suspicious filenames */
 	static SUSPICIOUS_FILENAME = /__|--/
@@ -64,14 +80,24 @@ export class SnapshotAuditor extends AuditorModel {
 	/** @type {number} Minimum filename length */
 	static MIN_FILENAME_LENGTH = 3
 
+	/** @type {string[]} Directories to ignore during scanning */
+	static IGNORE_DIRS = ['node_modules', '.git', '.venv', '.datasets', 'dist', 'build', 'types']
+
+	/**
+	 * Checks if a directory or file should be ignored.
+	 * @param {string} name
+	 * @returns {boolean}
+	 */
+	static isIgnored(name) {
+		return name.startsWith('.') || SnapshotAuditor.IGNORE_DIRS.includes(name)
+	}
+
 	/**
 	 * @param {Partial<SnapshotAuditor> | Record<string, any>} [data={}]
-	 * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
+	 * @param {Partial<import('@nan0web/ui').ModelAsAppOptions>} [options={}]
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)
-		/** @type {import('@nan0web/types').ModelOptions} */
-		this.options = options
 		/** @type {string} Target directory to audit */ this.dir
 		/** @type {string} Directory to scan for dictionaries */ this.data
 	}
@@ -104,106 +130,74 @@ export class SnapshotAuditor extends AuditorModel {
 		/** @type {Record<string, Set<string>>} */
 		const dicts = {}
 
-		let entries = []
 		try {
-			let entriesList;
-			try {
-				entriesList = await fsDb.listDir(data)
-			} catch (e) {
-				if (/** @type {any} */ (e).code === 'ENOENT' && !data.startsWith('../')) {
-					entriesList = await fsDb.listDir('../' + data)
-				} else {
-					throw e;
-				}
-			}
-			for (const e of entriesList) entries.push(e)
-		} catch (e) {
-			return dicts
-		}
-
-		for (const entry of entries) {
-			if (entry.stat.isDirectory && entry.name !== '_') {
-				const lang = entry.name
-				if (!dicts[lang]) dicts[lang] = new Set()
-
-				const scanLang = async (dirPath) => {
-					let files = []
-					try {
-						const entries = await fsDb.listDir(dirPath)
-						for (const f of entries) files.push(f)
-					} catch (e) {
-						return
+			// Find all language directories
+			const entries = await fsDb
+				.listDir(data)
+				.catch(async (e) => {
+					if (/** @type {any} */ (e).code === 'ENOENT' && !data.startsWith('../')) {
+						return await fsDb.listDir('../' + data)
 					}
-
-					for (const f of files) {
-						if (f.stat.isDirectory) {
-							await scanLang(f.path)
-						} else {
+					throw e
+				})
+				.catch(() => [])
+
+			for (const entry of entries) {
+				if (entry.stat.isDirectory && entry.name !== '_') {
+					const lang = entry.name
+					if (!dicts[lang]) dicts[lang] = new Set()
+
+					// Use browse for deep dictionary scanning
+					for await (const f of fsDb.browse(entry.path, { depth: Infinity })) {
+						if (SnapshotAuditor.isIgnored(f.name)) continue
+						if (f.isFile) {
 							try {
-								const _fsDb = /** @type {any} */ (fsDb)
-								const raw = _fsDb.FS ? await _fsDb.FS.loadTXT(_fsDb.location(f.path), '', true) : await fsDb.fetch(f.path)
+								const raw = await fsDb.fetch(f.path)
 								SnapshotAuditor.extractWords(raw, dicts[lang])
 							} catch (e) {}
 						}
 					}
 				}
-				await scanLang(entry.path)
 			}
+		} catch (e) {
+			// Ignore dictionary errors
 		}
 		return dicts
 	}
 
 	/**
 	 * Run the snapshot audit inside the target directory.
-	 * @returns {AsyncGenerator<import('@nan0web/ui').Intent, any, any>}
+	 * @returns {AsyncGenerator<import('@nan0web/ui').Intent, import('@nan0web/ui').ResultIntent, any>}
 	 */
 	async *run() {
-		const { t } = this.options
-		const snapshotsDir = this.dir || '.'
-
-		yield show(t(SnapshotAuditor.UI.starting, { dir: snapshotsDir }))
+		const { t } = /** @type {any} */ (this)._
 
-		const files = []
+		yield show(t(SnapshotAuditor.UI.starting, { dir: /** @type {any} */ (this).dir }))
 
-		/** @type {import('@nan0web/db').DB} */
-		let fsDb = this.options.db
-		if (fsDb && fsDb.mounts && fsDb.mounts.has('')) {
-			fsDb = /** @type {import('@nan0web/db').DB} */ (fsDb.mounts.get(''))
-		}
+		const fsDb = /** @type {any} */ (this)._.db
 
 		if (!fsDb) {
-			yield show('FS Database not provided to auditor', 'error')
+			yield show(t(SnapshotAuditor.UI.errorDb), 'error')
 			return result({ success: false })
 		}
 
-		const findSnapshots = async (dir) => {
-			try {
-				let entries;
-				try {
-					entries = await fsDb.listDir(dir)
-				} catch (e) {
-					if (/** @type {any} */ (e).code === 'ENOENT' && !dir.startsWith('../')) {
-						entries = await fsDb.listDir('../' + dir)
-					} else {
-						throw e;
-					}
-				}
-				for (const entry of entries) {
-					if (entry.stat.isDirectory) {
-						await findSnapshots(entry.path)
-					} else if (entry.name.endsWith('.nan0') || entry.name.endsWith('.txt')) {
-						files.push(entry.path)
-					}
+		const files = []
+		const snapshotsDir = fsDb.resolveSync(/** @type {any} */ (this).dir)
+
+		// Use robust DB.browse for recursive snapshot detection
+		try {
+			for await (const entry of fsDb.browse(snapshotsDir, { depth: Infinity })) {
+				if (SnapshotAuditor.isIgnored(entry.name)) continue
+				if (entry.isFile && (entry.name.endsWith('.nan0') || entry.name.endsWith('.txt'))) {
+					files.push(entry.path)
 				}
-			} catch (e) {
-				console.error('Error reading dir:', dir, e)
 			}
+		} catch (e) {
+			// Directory might be missing
 		}
 
-		await findSnapshots(snapshotsDir)
-
 		if (files.length === 0) {
-			yield show(t(SnapshotAuditor.UI.noSnapshots, { dir: snapshotsDir }), 'error')
+			yield show(t(SnapshotAuditor.UI.noSnapshots, { dir: this.dir }), 'error')
 			return result({ success: false })
 		}
 
@@ -216,8 +210,7 @@ export class SnapshotAuditor extends AuditorModel {
 			const locale = segments[segments.indexOf('core') + 1] || 'uk'
 			const componentName = segments.pop() || ''
 
-			const _fsDb = /** @type {any} */ (fsDb)
-			const content = _fsDb.FS ? await _fsDb.FS.loadTXT(_fsDb.location(file), '', true) : await fsDb.fetch(file)
+			const content = await fsDb.fetch(file)
 			const textContent = typeof content === 'string' ? content : JSON.stringify(content)
 
 			return {
@@ -231,14 +224,17 @@ export class SnapshotAuditor extends AuditorModel {
 		let hasErrors = false
 
 		for (const { file, audit } of results) {
-			const displayFile = file.startsWith('../') ? file.slice(3) : file
+			const displayFile = file.startsWith('@app/') ? file.slice(5) : file
 			if (audit.score < 100) {
 				const errorMessages = audit.errors.join('; ')
-				yield show(t(SnapshotAuditor.UI.auditFailed, { file: displayFile, errors: errorMessages }), 'error')
+				yield show(
+					t(SnapshotAuditor.UI.auditFailed, { file: displayFile, errors: errorMessages }),
+					'error',
+				)
 				allErrors.push(...audit.errors.map((e) => ({ file: displayFile, error: e })))
 				hasErrors = true
 			} else {
-				yield show(t(SnapshotAuditor.UI.auditPassed, { file: displayFile }), 'success')
+				yield progress(t(SnapshotAuditor.UI.auditPassed, { file: displayFile }))
 			}
 		}
 

package/src/domain/app/SnapshotRunner.js

@@ -36,7 +36,7 @@ export class SnapshotRunner extends Model {
 
 	/**
 	 * @param {Partial<SnapshotRunner> | Record<string, any>} [data={}]
-	 * @param {import('@nan0web/types').ModelOptions} [options={}]
+	 * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)

package/src/domain/app/UIApp.js

@@ -5,6 +5,11 @@ import GalleryCommand from './GalleryCommand.js'
 import ConfigApp from './ConfigApp.js'
 import { show, result } from '../../core/Intent.js'
 
+/**
+ * @property {string[]} _positionals
+ * @property {string} command Type of command to run
+ * @property {boolean} help Show help message
+ */
 export class UIApp extends ModelAsApp {
 	static command = {
 		type: 'string',
@@ -40,39 +45,25 @@ export class UIApp extends ModelAsApp {
 
 	/**
 	 * @param {Partial<UIApp> | Record<string, any>} [data={}]
-	 * @param {import('@nan0web/types').ModelOptions} [options={}]
+	 * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)
-		/** @type {string[]} */ this._positionals = []
-		/** @type {string} Type of command to run */ this.command
-		/** @type {boolean} Show help message */ this.help
 	}
 
 	async *run() {
 		const t = this._.t
-		if (this.help || this.command === 'help') {
-			yield show(t(UIApp.UI.helpText, undefined))
-			return result({})
-		}
+		const cmd = /** @type {any} */ (this).command
+		const help = /** @type {any} */ (this).help
 
-		const TargetCommand = UIApp.command.options.find((opt) =>
-			[opt.alias, opt.name].includes(this.command),
-		)
+		if (help) return yield* super.run()
 
-		if (!TargetCommand) {
-			yield show(t(UIApp.UI.unknownCommand, { command: this.command }), 'error')
+		if (!cmd || !(cmd instanceof ModelAsApp)) {
+			yield show(t(UIApp.UI.unknownCommand, { command: cmd }), 'error')
 			return result({ status: 'error' })
 		}
 
-		// Pass remaining positionals down to the target action
-		const nextData = resolvePositionalArgs(
-			/** @type {any} */ (TargetCommand),
-			this._positionals || [],
-			this
-		)
-		const intent = new TargetCommand(nextData, this._)
-		return yield* intent.run()
+		return yield* cmd.run()
 	}
 }
 

package/src/domain/components/ShellModel.js

@@ -37,7 +37,7 @@ export class ShellModel extends Model {
 		],
 		required: true,
 	}
-	
+
 	static data = {
 		help: 'Data source (DSN)',
 		type: 'string',
@@ -207,7 +207,7 @@ export class ShellModel extends Model {
 		if (!spawn) return yield log('error', 'Spawn missing')
 
 		const { existsSync } = await import('node:fs')
-		const viteConfig = existsSync('vite.docs.js') ? 'vite.docs.js' : 
+		const viteConfig = existsSync('vite.docs.js') ? 'vite.docs.js' :
 						  existsSync('vite.config.js') ? 'vite.config.js' : null
 
 		if (viteConfig) {