David Snelling
b3c4f348ab
Add production-ready Virtual File System with intelligent Knowledge Layer: Core VFS Features: - Complete file system operations (read, write, mkdir, etc.) - Intelligent PathResolver with 4-layer caching system - Chunked storage for large files with real compression - Embedding generation for semantic operations - File relationships and metadata tracking - Import functionality from local filesystem Knowledge Layer Integration: - EventRecorder for complete file history and temporal coupling - SemanticVersioning with content-based change detection - PersistentEntitySystem for character/entity tracking across files - ConceptSystem for universal concept mapping and graphs - GitBridge for import/export between VFS and Git repositories Architecture: - KnowledgeAugmentation properly integrated into Brainy augmentation system - KnowledgeLayer wrapper provides real-time VFS operation interception - Background processing ensures VFS operations remain fast - All components use real Brainy embed() method for embeddings - Support for creative writing, coding projects, and project management Technical Implementation: - Fixed all stub/mock implementations with real working code - TypeScript compilation passes without errors - Comprehensive test suite demonstrating all features - Documentation covering architecture and usage patterns - Backwards compatible with existing Brainy functionality This enables scenarios like writing books with persistent characters, managing coding projects with concept tracking, and complete project coordination with intelligent file relationships.
87 lines
No EOL
1.9 KiB
TypeScript
87 lines
No EOL
1.9 KiB
TypeScript
/**
|
|
* VFS Write Stream Implementation
|
|
*
|
|
* Real streaming write support for large files
|
|
*/
|
|
|
|
import { Writable } from 'stream'
|
|
import { VirtualFileSystem } from '../VirtualFileSystem.js'
|
|
import { WriteStreamOptions } from '../types.js'
|
|
|
|
export class VFSWriteStream extends Writable {
|
|
private chunks: Buffer[] = []
|
|
private size = 0
|
|
private _closed = false
|
|
|
|
constructor(
|
|
private vfs: VirtualFileSystem,
|
|
private path: string,
|
|
private options: WriteStreamOptions = {}
|
|
) {
|
|
super({
|
|
highWaterMark: 64 * 1024 // 64KB chunks
|
|
})
|
|
|
|
// Handle autoClose option
|
|
if (options.autoClose !== false) {
|
|
this.once('finish', () => this._flush())
|
|
}
|
|
}
|
|
|
|
async _write(
|
|
chunk: any,
|
|
encoding: BufferEncoding,
|
|
callback: (error?: Error | null) => void
|
|
): Promise<void> {
|
|
try {
|
|
// Convert to buffer if needed
|
|
const buffer = Buffer.isBuffer(chunk)
|
|
? chunk
|
|
: Buffer.from(chunk, encoding)
|
|
|
|
// Store chunk
|
|
this.chunks.push(buffer)
|
|
this.size += buffer.length
|
|
|
|
// For very large files, we could flush periodically
|
|
// to avoid memory issues, but for now we accumulate
|
|
|
|
callback()
|
|
} catch (error: any) {
|
|
callback(error)
|
|
}
|
|
}
|
|
|
|
async _final(callback: (error?: Error | null) => void): Promise<void> {
|
|
try {
|
|
await this._flush()
|
|
callback()
|
|
} catch (error: any) {
|
|
callback(error)
|
|
}
|
|
}
|
|
|
|
private async _flush(): Promise<void> {
|
|
if (this._closed) return
|
|
this._closed = true
|
|
|
|
// Combine all chunks
|
|
const data = Buffer.concat(this.chunks, this.size)
|
|
|
|
// Write to VFS
|
|
await this.vfs.writeFile(this.path, data, {
|
|
mode: this.options.mode,
|
|
encoding: this.options.encoding
|
|
})
|
|
|
|
// Clear chunks to free memory
|
|
this.chunks = []
|
|
}
|
|
|
|
_destroy(error: Error | null, callback: (error?: Error | null) => void): void {
|
|
// Clean up resources
|
|
this.chunks = []
|
|
this._closed = true
|
|
callback(error)
|
|
}
|
|
} |