@allternit/gizzi-code 1.0.0 → 1.0.1

package/src/watcher/WorkspaceWatcher.ts

@@ -1,251 +0,0 @@
-/**
- * Gizzi Workspace File Watcher
- * 
- * Monitors agent workspace files for changes and triggers context refresh.
- */
-
-import type { FileSystem } from '../workspace/loader';
-
-export interface FileChange {
-  path: string;
-  type: 'created' | 'modified' | 'deleted';
-  previousModTime?: Date;
-  currentModTime?: Date;
-}
-
-interface WatchedFile {
-  path: string;
-  lastModified: Date;
-  size: number;
-}
-
-export interface WatcherOptions {
-  pollIntervalMs: number;
-  onChange: (changes: FileChange[]) => void;
-  onError?: (error: Error) => void;
-}
-
-/**
- * Workspace File Watcher for Gizzi
- */
-export class WorkspaceWatcher {
-  private agentId: string;
-  private basePath: string;
-  private fs: FileSystem;
-  private options: WatcherOptions;
-  private intervalId: NodeJS.Timeout | null = null;
-  private watchedFiles = new Map<string, WatchedFile>();
-  private isWatching = false;
-
-  constructor(
-    agentId: string,
-    basePath: string,
-    fs: FileSystem,
-    options: Partial<WatcherOptions> = {}
-  ) {
-    this.agentId = agentId;
-    this.basePath = basePath;
-    this.fs = fs;
-    this.options = {
-      pollIntervalMs: 5000,
-      onChange: () => {},
-      ...options,
-    };
-  }
-
-  /**
-   * Start watching for changes
-   */
-  async start(): Promise<void> {
-    if (this.isWatching) {
-      console.log(`[WorkspaceWatcher] Already watching ${this.agentId}`);
-      return;
-    }
-
-    // Initial scan
-    try {
-      await this.scanWorkspace();
-    } catch (error) {
-      console.error(`[WorkspaceWatcher] Initial scan failed:`, error);
-      this.options.onError?.(error as Error);
-      return;
-    }
-
-    // Start polling
-    this.isWatching = true;
-    this.intervalId = setInterval(() => {
-      this.checkForChanges().catch((error) => {
-        console.error(`[WorkspaceWatcher] Check failed:`, error);
-        this.options.onError?.(error);
-      });
-    }, this.options.pollIntervalMs);
-
-    console.log(`[WorkspaceWatcher] Started watching ${this.agentId} (${this.options.pollIntervalMs}ms interval)`);
-  }
-
-  /**
-   * Stop watching
-   */
-  stop(): void {
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-    }
-    this.isWatching = false;
-    console.log(`[WorkspaceWatcher] Stopped watching ${this.agentId}`);
-  }
-
-  /**
-   * Get current watch status
-   */
-  getStatus(): {
-    isWatching: boolean;
-    filesWatched: number;
-  } {
-    return {
-      isWatching: this.isWatching,
-      filesWatched: this.watchedFiles.size,
-    };
-  }
-
-  /**
-   * Force a manual refresh
-   */
-  async refresh(): Promise<FileChange[]> {
-    return this.checkForChanges();
-  }
-
-  /**
-   * Scan workspace for files
-   */
-  private async scanWorkspace(): Promise<void> {
-    this.watchedFiles.clear();
-
-    const entries = await this.fs.listDirectory(this.basePath);
-
-    for (const entry of entries) {
-      if (entry.type === 'file') {
-        const filePath = `${this.basePath}/${entry.name}`;
-        try {
-          const content = await this.fs.readFile(filePath);
-          this.watchedFiles.set(entry.name, {
-            path: entry.name,
-            lastModified: new Date(), // We don't have actual mtime from FileSystem interface
-            size: content.length,
-          });
-        } catch {
-          // Skip files we can't read
-        }
-      }
-    }
-  }
-
-  /**
-   * Check for changes
-   */
-  private async checkForChanges(): Promise<FileChange[]> {
-    const changes: FileChange[] = [];
-    const currentFiles = new Map<string, WatchedFile>();
-
-    try {
-      const entries = await this.fs.listDirectory(this.basePath);
-
-      for (const entry of entries) {
-        if (entry.type !== 'file') continue;
-
-        const filePath = `${this.basePath}/${entry.name}`;
-        
-        try {
-          const content = await this.fs.readFile(filePath);
-          const previousFile = this.watchedFiles.get(entry.name);
-          
-          currentFiles.set(entry.name, {
-            path: entry.name,
-            lastModified: new Date(),
-            size: content.length,
-          });
-
-          if (!previousFile) {
-            // New file
-            changes.push({
-              path: entry.name,
-              type: 'created',
-              currentModTime: new Date(),
-            });
-          } else if (content.length !== previousFile.size) {
-            // Modified file (using size as proxy for modification)
-            changes.push({
-              path: entry.name,
-              type: 'modified',
-              previousModTime: previousFile.lastModified,
-              currentModTime: new Date(),
-            });
-          }
-        } catch {
-          // Skip files we can't read
-        }
-      }
-
-      // Check for deleted files
-      for (const [name, file] of this.watchedFiles) {
-        if (!currentFiles.has(name)) {
-          changes.push({
-            path: name,
-            type: 'deleted',
-            previousModTime: file.lastModified,
-          });
-        }
-      }
-
-      // Update state
-      this.watchedFiles = currentFiles;
-
-      // Notify if changes detected
-      if (changes.length > 0) {
-        console.log(`[WorkspaceWatcher] Detected ${changes.length} changes in ${this.agentId}:`,
-          changes.map(c => `${c.type}:${c.path}`).join(', '));
-        this.options.onChange(changes);
-      }
-    } catch (error) {
-      console.error(`[WorkspaceWatcher] Failed to check for changes:`, error);
-      this.options.onError?.(error as Error);
-    }
-
-    return changes;
-  }
-}
-
-// Global watcher registry
-const watchers = new Map<string, WorkspaceWatcher>();
-
-/**
- * Get or create a watcher for an agent
- */
-export function getWorkspaceWatcher(
-  agentId: string,
-  basePath: string,
-  fs: FileSystem,
-  options?: Partial<WatcherOptions>
-): WorkspaceWatcher {
-  if (!watchers.has(agentId)) {
-    watchers.set(agentId, new WorkspaceWatcher(agentId, basePath, fs, options));
-  }
-  return watchers.get(agentId)!;
-}
-
-/**
- * Stop all watchers
- */
-export function stopAllWatchers(): void {
-  for (const [agentId, watcher] of watchers) {
-    watcher.stop();
-  }
-  watchers.clear();
-}
-
-// Export singleton for global access
-export const workspaceWatcher = {
-  watchers,
-  getWatcher: getWorkspaceWatcher,
-  stopAll: stopAllWatchers,
-};

package/src/workspace/loader.d.ts

@@ -1,30 +0,0 @@
-/**
- * Gizzi Workspace Loader
- *
- * Loads agent workspace files and integrates with Gizzi state
- */
-import type { WorkspaceSession, ContextPack } from './types';
-import { getStartupTasks } from '../context/pack-builder';
-export interface FileSystem {
-    readFile(path: string): Promise<string>;
-    listDirectory(path: string): Promise<{
-        name: string;
-        type: 'file' | 'directory';
-    }[]>;
-    exists(path: string): Promise<boolean>;
-}
-export interface LoadWorkspaceOptions {
-    agentId: string;
-    agentName: string;
-    sessionId: string;
-    fs: FileSystem;
-    basePath: string;
-}
-export interface LoadedWorkspace {
-    files: Map<string, string>;
-    contextPack: ContextPack;
-    startupTasks: ReturnType<typeof getStartupTasks>;
-}
-export declare function loadWorkspace(options: LoadWorkspaceOptions): Promise<LoadedWorkspace | null>;
-export declare function executeStartupTasks(tasks: LoadedWorkspace['startupTasks'], sendMessage: (content: string) => void): Promise<void>;
-export declare function enhanceSessionWithWorkspace(session: WorkspaceSession, workspace: LoadedWorkspace): WorkspaceSession;

package/src/workspace/loader.js

@@ -1,117 +0,0 @@
-/**
- * Gizzi Workspace Loader
- *
- * Loads agent workspace files and integrates with Gizzi state
- */
-import { buildContextPack, getStartupTasks } from '../context/pack-builder';
-// ============================================================================
-// Workspace File Patterns
-// ============================================================================
-const WORKSPACE_FILE_PATTERNS = [
-    '.allternit/manifest.json',
-    '.allternit/brain/BRAIN.md',
-    '.allternit/memory/MEMORY.md',
-    '.allternit/memory/active-tasks.md',
-    '.allternit/memory/daily.md',
-    '.allternit/memory/lessons.md',
-    '.allternit/memory/self-review.md',
-    '.allternit/identity/IDENTITY.md',
-    '.allternit/identity/SOUL.md',
-    '.allternit/identity/USER.md',
-    '.allternit/identity/VOICE.md',
-    '.allternit/identity/POLICY.md',
-    '.allternit/governance/PLAYBOOK.md',
-    '.allternit/governance/TOOLS.md',
-    '.allternit/governance/HEARTBEAT.md',
-    '.allternit/governance/SYSTEM.md',
-    '.allternit/governance/CHANNELS.md',
-    '.allternit/skills/**',
-    '.allternit/business/CLIENTS.md',
-];
-export async function loadWorkspace(options) {
-    const { agentId, agentName, sessionId, fs, basePath } = options;
-    console.log('[Gizzi Workspace] Loading workspace for agent:', agentId);
-    const files = new Map();
-    // Load core files
-    for (const pattern of WORKSPACE_FILE_PATTERNS) {
-        if (pattern.includes('**'))
-            continue;
-        const fullPath = `${basePath}/${pattern}`;
-        try {
-            if (await fs.exists(fullPath)) {
-                const content = await fs.readFile(fullPath);
-                files.set(pattern, content);
-            }
-        }
-        catch {
-            // File doesn't exist, skip
-        }
-    }
-    // Load skill files
-    try {
-        const skillsPath = `${basePath}/.allternit/skills`;
-        if (await fs.exists(skillsPath)) {
-            const entries = await fs.listDirectory(skillsPath);
-            for (const entry of entries) {
-                if (entry.type === 'file' && (entry.name.endsWith('.md') || entry.name.endsWith('.json'))) {
-                    const content = await fs.readFile(`${skillsPath}/${entry.name}`);
-                    files.set(`.allternit/skills/${entry.name}`, content);
-                }
-            }
-        }
-    }
-    catch {
-        // Skills directory doesn't exist
-    }
-    if (files.size === 0) {
-        console.log('[Gizzi Workspace] No workspace files found');
-        return null;
-    }
-    console.log(`[Gizzi Workspace] Loaded ${files.size} files`);
-    // Build context pack
-    const contextPack = buildContextPack({
-        sessionId,
-        agentId,
-        agentName,
-        files,
-    });
-    // Get startup tasks
-    const startupTasks = getStartupTasks(contextPack);
-    console.log(`[Gizzi Workspace] ${startupTasks.length} startup tasks to execute`);
-    return { files, contextPack, startupTasks };
-}
-// ============================================================================
-// Execute Startup Tasks
-// ============================================================================
-export async function executeStartupTasks(tasks, sendMessage) {
-    for (const task of tasks) {
-        console.log(`[Gizzi Workspace] Executing startup task: ${task.action}`);
-        // Execute the task
-        // For now, just log it - in production this would perform actual actions
-        try {
-            // Simulate task execution
-            await new Promise(resolve => setTimeout(resolve, 100));
-            // Optionally send a message about the task
-            if (task.action.toLowerCase().includes('greet') || task.action.toLowerCase().includes('introduce')) {
-                // Don't auto-send, let the agent handle it naturally
-            }
-            task.lastExecuted = new Date().toISOString();
-        }
-        catch (error) {
-            console.error(`[Gizzi Workspace] Task failed:`, error);
-        }
-    }
-}
-// ============================================================================
-// Session Enhancement
-// ============================================================================
-export function enhanceSessionWithWorkspace(session, workspace) {
-    return {
-        ...session,
-        mode: 'agent',
-        contextPack: workspace.contextPack,
-        contextHash: workspace.contextPack.hash,
-        contextRefreshedAt: new Date().toISOString(),
-        workspaceFiles: Array.from(workspace.files.keys()),
-    };
-}

package/src/workspace/types.d.ts

@@ -1,91 +0,0 @@
-/**
- * Gizzi Workspace Types
- *
- * Type definitions for agent workspace system
- * mirrors the Allternit platform implementation
- */
-export type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
-export interface WorkspaceFile {
-    path: string;
-    name: string;
-    content: string;
-    type: 'manifest' | 'brain' | 'memory' | 'identity' | 'soul' | 'user' | 'voice' | 'policy' | 'playbook' | 'tools' | 'heartbeat' | 'system' | 'channels' | 'skill' | 'business' | 'knowledge' | 'config';
-    size: number;
-}
-export interface TrustTier {
-    level: 1 | 2 | 3;
-    name: string;
-    rules: string[];
-    enforce: 'always' | 'contextual' | 'permission';
-}
-export interface ScheduledTask {
-    id: string;
-    frequency: 'on-session-start' | 'daily' | 'weekly' | 'monthly' | 'on-event';
-    action: string;
-    condition?: string;
-    lastExecuted?: string;
-}
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    requiresPermission: boolean;
-    permissionLevel: 1 | 2 | 3;
-}
-export interface ContextPack {
-    version: '1.0.0';
-    agentId: string;
-    agentName: string;
-    sessionId: string;
-    identity: {
-        name: string;
-        purpose: string;
-        backstory: string;
-        personalityTraits: string[];
-    };
-    trustTiers: {
-        tier1: TrustTier;
-        tier2: TrustTier;
-        tier3: TrustTier;
-    };
-    governance: {
-        playbook: string;
-        availableTools: ToolDefinition[];
-        hardBans: string[];
-        escalation: string[];
-    };
-    heartbeat: {
-        tasks: ScheduledTask[];
-        lastCheck: string;
-    };
-    memory: {
-        brain: string;
-        activeTasks: string[];
-        lessons: string[];
-        userPreferences: Record<string, unknown>;
-    };
-    voice: {
-        style: string;
-        tone: {
-            formality: number;
-            enthusiasm: number;
-            empathy: number;
-            directness: number;
-        };
-        rules: string[];
-    };
-    systemPrompt: string;
-    hash: string;
-    createdAt: string;
-    expiresAt: string;
-}
-export interface WorkspaceSession {
-    id: string;
-    name: string;
-    mode: 'regular' | 'agent';
-    agentId?: string;
-    agentName?: string;
-    contextPack?: ContextPack;
-    contextHash?: string;
-    contextRefreshedAt?: string;
-    workspaceFiles?: string[];
-}

package/src/workspace/types.js

@@ -1,7 +0,0 @@
-/**
- * Gizzi Workspace Types
- *
- * Type definitions for agent workspace system
- * mirrors the Allternit platform implementation
- */
-export {};

package/threads/thread_1775361175022.json

@@ -1,9 +0,0 @@
-{
-  "id": "thread_1775361175022",
-  "parentId": null,
-  "title": "Thread 61175022",
-  "createdAt": "2026-04-05T03:52:55.022Z",
-  "lastActiveAt": "2026-04-05T03:52:55.022Z",
-  "messageCount": 0,
-  "status": "active"
-}

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "jsx": "react-jsx"
-  },
-  "include": ["src/**/*"]
-}