@allternit/gizzi-code 1.0.0

package/WORKSPACE_INTEGRATION.md

@@ -0,0 +1,290 @@
+# Gizzi Code - Workspace Integration
+
+## Overview
+
+Gizzi Code now supports **agent workspace files** - the same production-quality implementation as the Allternit Platform.
+
+## Features
+
+### ✅ Workspace File Loading
+- SOUL.md (trust tiers, self-awareness)
+- HEARTBEAT.md (periodic tasks)
+- IDENTITY.md (core identity)
+- PLAYBOOK.md (execution rules)
+- TOOLS.md (tool inventory)
+- VOICE.md (communication style)
+- BRAIN.md, MEMORY.md (memory system)
+- And all other workspace files
+
+### ✅ Trust Tier Enforcement
+SOUL.md trust tiers are parsed and enforced:
+- **Tier 1**: Always apply (hard rules)
+- **Tier 2**: Context-dependent (apply when relevant)
+- **Tier 3**: Permission required (ask user first)
+
+### ✅ HEARTBEAT Task Execution
+HEARTBEAT.md tasks are executed on session start:
+- `on-session-start` tasks run immediately
+- Future: `daily`, `weekly`, `monthly` scheduled tasks
+
+### ✅ Context Sent with Every Message
+Full context pack sent to AI on every interaction:
+```typescript
+{
+  systemPrompt: 'Complete agent identity and rules',
+  trustTiers: { tier1, tier2, tier3 },
+  governance: { playbook, tools, hardBans },
+  heartbeat: { tasks },
+  memory: { brain, activeTasks, lessons }
+}
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { getWorkspaceStore, loadWorkspace } from '@gizzi/code';
+
+// Get the workspace-enabled store
+const store = getWorkspaceStore();
+
+// Configure filesystem
+store.setFileSystem({
+  readFile: async (path) => { /* ... */ },
+  listDirectory: async (path) => { /* ... */ },
+  exists: async (path) => { /* ... */ },
+}, '/path/to/agent/workspace');
+```
+
+### Activate Agent Mode
+
+```typescript
+// Activate agent with workspace
+const success = await store.activateAgentMode('my-agent', 'My Custom Agent');
+
+if (success) {
+  console.log('Agent mode activated with workspace context');
+  
+  // Send message with automatic context inclusion
+  await store.sendMessageWithContext('Hello!');
+}
+```
+
+### Check Trust Tiers
+
+```typescript
+// Before executing sensitive actions
+if (store.requiresPermission('deploy_to_production')) {
+  await askUserPermission('Deploy to production?');
+}
+
+// Get full trust tiers
+const tiers = store.getTrustTiers();
+console.log('Tier 1 rules:', tiers?.tier1.rules);
+```
+
+### Get System Prompt
+
+```typescript
+// Get the complete system prompt built from workspace
+const systemPrompt = store.getSystemPrompt();
+console.log(systemPrompt);
+```
+
+## Workspace File Structure
+
+```
+agents/{agent-id}/
+└── .allternit/
+    ├── manifest.json
+    ├── brain/BRAIN.md
+    ├── memory/
+    │   ├── MEMORY.md
+    │   ├── active-tasks.md
+    │   ├── daily.md
+    │   ├── lessons.md
+    │   └── self-review.md
+    ├── identity/
+    │   ├── IDENTITY.md
+    │   ├── SOUL.md          ← Trust tiers (CRITICAL)
+    │   ├── USER.md
+    │   ├── VOICE.md
+    │   └── POLICY.md
+    ├── governance/
+    │   ├── PLAYBOOK.md
+    │   ├── TOOLS.md
+    │   ├── HEARTBEAT.md     ← Scheduled tasks (CRITICAL)
+    │   ├── SYSTEM.md
+    │   └── CHANNELS.md
+    ├── skills/
+    │   └── _template/
+    │       ├── SKILL.md
+    │       └── contract.json
+    └── business/
+        └── CLIENTS.md
+```
+
+## SOUL.md Example
+
+```markdown
+# SOUL.md — Agent's Soul Configuration
+
+## Tier 1 — Foundation
+✅ Always apply:
+- Respect user privacy
+- Be transparent about capabilities
+- Never execute code without permission
+
+## Tier 2 — Contextual
+- Adapt tone to user's expertise level
+- Offer alternatives when uncertain
+
+## Tier 3 — Permission Required
+- Access external APIs
+- Execute shell commands
+- Modify production systems
+- Access sensitive user data
+
+## Self-Awareness
+I am {agent_name}, an AI assistant specialized in {specialty}.
+I aim to be helpful while respecting safety boundaries.
+```
+
+## HEARTBEAT.md Example
+
+```markdown
+# HEARTBEAT.md — Periodic Tasks
+
+## On Session Start
+- [ ] Load recent context from memory
+- [ ] Check for pending user requests
+- [ ] Initialize tool connections
+
+## Daily
+- [ ] Memory compaction
+- [ ] Self-review of recent interactions
+
+## Weekly
+- [ ] Performance analysis
+- [ ] Update knowledge base
+```
+
+## API Reference
+
+### WorkspaceStateStore
+
+```typescript
+class WorkspaceStateStore extends AppStateStore {
+  // Configuration
+  setFileSystem(fs: FileSystem, basePath: string): void
+  
+  // Agent Mode
+  activateAgentMode(agentId: string, agentName: string): Promise<boolean>
+  resetAgentMode(): void
+  
+  // Messaging with Context
+  sendMessageWithContext(
+    content: string,
+    options?: { skipContext?: boolean }
+  ): Promise<void>
+  
+  // Context Access
+  getContextPack(): ContextPack | null
+  getSystemPrompt(): string
+  getTrustTiers(): TrustTiers | null
+  requiresPermission(action: string): boolean
+  isAgentMode(): boolean
+}
+```
+
+### Context Pack
+
+```typescript
+interface ContextPack {
+  version: '1.0.0';
+  agentId: string;
+  agentName: string;
+  sessionId: string;
+  
+  identity: {
+    name: string;
+    purpose: string;
+    backstory: string;
+    personalityTraits: string[];
+  };
+  
+  trustTiers: {
+    tier1: TrustTier;  // Always apply
+    tier2: TrustTier;  // Context-dependent
+    tier3: TrustTier;  // Permission required
+  };
+  
+  governance: {
+    playbook: string;
+    availableTools: ToolDefinition[];
+    hardBans: string[];
+  };
+  
+  heartbeat: {
+    tasks: ScheduledTask[];
+    lastCheck: string;
+  };
+  
+  systemPrompt: string;  // Complete prompt for AI
+  hash: string;          // For caching
+}
+```
+
+## Integration Example
+
+```typescript
+import { getWorkspaceStore } from '@gizzi/code';
+
+async function main() {
+  const store = getWorkspaceStore();
+  
+  // Setup filesystem (example using Node.js fs)
+  store.setFileSystem(
+    {
+      readFile: async (path) => await fs.readFile(path, 'utf-8'),
+      listDirectory: async (path) => await fs.readdir(path, { withFileTypes: true })
+        .then(entries => entries.map(e => ({ name: e.name, type: e.isDirectory() ? 'directory' : 'file' }))),
+      exists: async (path) => await fs.access(path).then(() => true).catch(() => false),
+    },
+    '/Users/me/agents/my-agent'
+  );
+  
+  // Activate agent
+  await store.activateAgentMode('my-agent', 'Code Assistant');
+  
+  // Check permissions before action
+  if (store.requiresPermission('execute_shell_command')) {
+    const approved = await confirm('Execute: rm -rf /?');
+    if (!approved) return;
+  }
+  
+  // Send message (context automatically included)
+  await store.sendMessageWithContext('Help me refactor this code');
+}
+```
+
+## Determinism
+
+The workspace system is **deterministic**:
+1. Files are loaded in a specific order
+2. Context pack is built with consistent structure
+3. Same workspace files → same system prompt → same AI behavior
+4. Context hash ensures cache consistency
+
+## Next Steps
+
+1. Implement backend AI integration that accepts context packs
+2. ~~Add file watcher for automatic context refresh~~ ✅ Done
+3. ~~Implement scheduled task execution (cron)~~ ✅ Done
+4. Add context pack versioning
+
+## See Also
+
+- Allternit Platform Workspace Implementation (mirrors this)
+- `WORKSPACE_PRODUCTION_IMPLEMENTATION.md` in Allternit codebase

package/chat-sessions/sessions-index.json

@@ -0,0 +1,98 @@
+[
+  {
+    "sessionId": "sess_1774559556358",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_1774559556358",
+    "title": "Test Chat Session",
+    "messageCount": 0,
+    "created": 1774559556358,
+    "modified": 1774559556358
+  },
+  {
+    "sessionId": "sess_1774559556361",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_1774559556361",
+    "title": "Test",
+    "messageCount": 0,
+    "created": 1774559556361,
+    "modified": 1774559556361
+  },
+  {
+    "sessionId": "sess_1774559557365",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_1774559557365",
+    "title": "Chat Session",
+    "messageCount": 0,
+    "created": 1774559557365,
+    "modified": 1774559557365
+  },
+  {
+    "sessionId": "sess_1774559557367",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_1774559557367",
+    "title": "Chat",
+    "messageCount": 0,
+    "created": 1774559557367,
+    "modified": 1774559557368
+  },
+  {
+    "sessionId": "sess_retry",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_retry",
+    "title": "Retry Success",
+    "messageCount": 0,
+    "created": 1774559560441,
+    "modified": 1774559560441
+  },
+  {
+    "sessionId": "sess_retry",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_retry",
+    "title": "Retry Success",
+    "messageCount": 0,
+    "created": 1774559561443,
+    "modified": 1774559561443
+  },
+  {
+    "sessionId": "sess_1774559746746",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_1774559746746",
+    "title": "Test Chat Session",
+    "messageCount": 0,
+    "created": 1774559746746,
+    "modified": 1774559746746
+  },
+  {
+    "sessionId": "sess_1774559746749",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_1774559746749",
+    "title": "Test",
+    "messageCount": 0,
+    "created": 1774559746749,
+    "modified": 1774559746749
+  },
+  {
+    "sessionId": "sess_1774559747751",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_1774559747751",
+    "title": "Chat Session",
+    "messageCount": 0,
+    "created": 1774559747751,
+    "modified": 1774559747752
+  },
+  {
+    "sessionId": "sess_1774559747753",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_1774559747753",
+    "title": "Chat",
+    "messageCount": 0,
+    "created": 1774559747753,
+    "modified": 1774559747754
+  },
+  {
+    "sessionId": "sess_retry",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_retry",
+    "title": "Retry Success",
+    "messageCount": 0,
+    "created": 1774559750761,
+    "modified": 1774559750761
+  },
+  {
+    "sessionId": "sess_retry",
+    "fullPath": "/Users/macbook/.gizzi/chat-sessions/sess_retry",
+    "title": "Retry Success",
+    "messageCount": 0,
+    "created": 1774559751764,
+    "modified": 1774559751764
+  }
+]

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@allternit/gizzi-code",
+  "version": "1.0.0",
+  "description": "Gizzi Code - Workspace-aware AI assistant framework (like Claude Code for Allternit)",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc || true",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit || true"
+  },
+  "keywords": [
+    "allternit",
+    "gizzi",
+    "cli",
+    "ai",
+    "assistant",
+    "workspace"
+  ],
+  "author": "Allternit",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/package.json.original

@@ -0,0 +1,31 @@
+{
+  "name": "@gizzi/code",
+  "version": "1.0.0",
+  "description": "Gizzi Code - Workspace-aware AI assistant framework",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@allternit/plugin": "link:/Users/macbook/Desktop/allternit-workspace/allternit/cmd/gizzi-code/packages/plugin",
+    "@a2r/plugin": "link:/Users/macbook/Desktop/a2rchitech-workspace/a2rchitech/cmd/gizzi-code/packages/plugin"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0"
+  }
+}

package/package.json.publish

@@ -0,0 +1,47 @@
+{
+  "name": "@allternit/gizzi-code",
+  "version": "1.0.0",
+  "description": "Gizzi Code - Workspace-aware AI assistant framework (like Claude Code for Allternit)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "gizzi": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "allternit",
+    "gizzi",
+    "cli",
+    "ai",
+    "assistant",
+    "workspace"
+  ],
+  "author": "Allternit",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/bootstrap/state.d.ts

@@ -0,0 +1,169 @@
+/**
+ * @fileoverview Bootstrap state management for gizzi-code integration
+ * @module bootstrap/state
+ *
+ * Manages application initialization state, loading phases, and bootstrap
+ * lifecycle events. Provides centralized state tracking during application startup.
+ */
+import type { TypedMessage } from '../types/message';
+/**
+ * Loading phase identifiers for the bootstrap process
+ * @typedef {'idle' | 'initializing' | 'loading_config' | 'connecting' | 'authenticating' | 'ready' | 'error'} LoadingPhase
+ */
+export type LoadingPhase = 'idle' | 'initializing' | 'loading_config' | 'connecting' | 'authenticating' | 'ready' | 'error';
+/**
+ * Valid loading phase transitions
+ * @constant {Record<LoadingPhase, readonly LoadingPhase[]>}
+ */
+export declare const VALID_PHASE_TRANSITIONS: Readonly<Record<LoadingPhase, readonly LoadingPhase[]>>;
+/**
+ * Bootstrap error structure
+ * @interface BootstrapError
+ */
+export interface BootstrapError {
+    /** Error code for programmatic handling */
+    readonly code: string;
+    /** Human-readable error message */
+    readonly message: string;
+    /** Error timestamp */
+    readonly timestamp: Date;
+    /** Optional error details or stack trace */
+    readonly details?: string;
+    /** Phase where the error occurred */
+    readonly phase: LoadingPhase;
+}
+/**
+ * Bootstrap state interface tracking initialization progress
+ * @interface BootstrapState
+ */
+export interface BootstrapState {
+    /** Current loading phase */
+    readonly phase: LoadingPhase;
+    /** Overall progress percentage (0-100) */
+    readonly progress: number;
+    /** Whether the application has completed bootstrap */
+    readonly isComplete: boolean;
+    /** Whether an error has occurred during bootstrap */
+    readonly hasError: boolean;
+    /** Current error if any */
+    readonly error: BootstrapError | null;
+    /** Timestamp when bootstrap started */
+    readonly startTime: Date | null;
+    /** Timestamp when bootstrap completed */
+    readonly endTime: Date | null;
+    /** Messages collected during initialization */
+    readonly messages: readonly TypedMessage[];
+    /** Configuration data loaded during bootstrap */
+    readonly config: Readonly<Record<string, unknown>>;
+    /** Services initialized during bootstrap */
+    readonly services: readonly string[];
+}
+/**
+ * Listener callback type for state changes
+ * @typedef {(state: BootstrapState) => void} StateChangeListener
+ */
+type StateChangeListener = (state: BootstrapState) => void;
+/**
+ * Gets the current bootstrap state
+ * @returns {Readonly<BootstrapState>} The current bootstrap state (immutable)
+ * @example
+ * ```typescript
+ * const state = getBootstrapState();
+ * if (state.phase === 'ready') {
+ *   console.log('Application is ready');
+ * }
+ * ```
+ */
+export declare function getBootstrapState(): Readonly<BootstrapState>;
+/**
+ * Sets the bootstrap state with partial updates
+ * Automatically notifies all registered listeners
+ *
+ * @param {Partial<BootstrapState>} updates - Partial state updates to apply
+ * @returns {Readonly<BootstrapState>} The updated state
+ * @throws {Error} If attempting an invalid phase transition
+ * @example
+ * ```typescript
+ * setBootstrapState({ phase: 'initializing', progress: 10 });
+ * ```
+ */
+export declare function setBootstrapState(updates: Partial<BootstrapState>): Readonly<BootstrapState>;
+/**
+ * Subscribes to bootstrap state changes
+ *
+ * @param {StateChangeListener} listener - Callback function to invoke on state changes
+ * @returns {() => void} Unsubscribe function
+ * @example
+ * ```typescript
+ * const unsubscribe = subscribeToBootstrapState((state) => {
+ *   console.log('Phase:', state.phase);
+ * });
+ * // Later: unsubscribe();
+ * ```
+ */
+export declare function subscribeToBootstrapState(listener: StateChangeListener): () => void;
+/**
+ * Resets the bootstrap state to initial values
+ * Useful for testing or re-initializing the application
+ *
+ * @param {boolean} [notifyListeners=true] - Whether to notify listeners of the reset
+ * @returns {Readonly<BootstrapState>} The reset state
+ */
+export declare function resetBootstrapState(notifyListeners?: boolean): Readonly<BootstrapState>;
+/**
+ * Starts the bootstrap process
+ * Sets phase to 'initializing' and records start time
+ *
+ * @returns {Readonly<BootstrapState>} The updated state
+ */
+export declare function startBootstrap(): Readonly<BootstrapState>;
+/**
+ * Reports a bootstrap error
+ * Sets phase to 'error' and records error details
+ *
+ * @param {string} code - Error code
+ * @param {string} message - Error message
+ * @param {string} [details] - Optional error details
+ * @returns {Readonly<BootstrapState>} The updated state
+ */
+export declare function setBootstrapError(code: string, message: string, details?: string): Readonly<BootstrapState>;
+/**
+ * Completes the bootstrap process
+ * Sets phase to 'ready' and records completion time
+ *
+ * @returns {Readonly<BootstrapState>} The updated state
+ */
+export declare function completeBootstrap(): Readonly<BootstrapState>;
+/**
+ * Gets the estimated time remaining for bootstrap
+ *
+ * @returns {number | null} Estimated milliseconds remaining, or null if not available
+ */
+export declare function getEstimatedTimeRemaining(): number | null;
+/**
+ * Adds a message to the bootstrap state
+ *
+ * @param {TypedMessage} message - The message to add
+ * @returns {Readonly<BootstrapState>} The updated state
+ */
+export declare function addBootstrapMessage(message: TypedMessage): Readonly<BootstrapState>;
+/**
+ * Registers a service as initialized
+ *
+ * @param {string} serviceName - Name of the service
+ * @returns {Readonly<BootstrapState>} The updated state
+ */
+export declare function registerService(serviceName: string): Readonly<BootstrapState>;
+declare const _default: {
+    getBootstrapState: typeof getBootstrapState;
+    setBootstrapState: typeof setBootstrapState;
+    subscribeToBootstrapState: typeof subscribeToBootstrapState;
+    resetBootstrapState: typeof resetBootstrapState;
+    startBootstrap: typeof startBootstrap;
+    completeBootstrap: typeof completeBootstrap;
+    setBootstrapError: typeof setBootstrapError;
+    addBootstrapMessage: typeof addBootstrapMessage;
+    registerService: typeof registerService;
+    getEstimatedTimeRemaining: typeof getEstimatedTimeRemaining;
+};
+export default _default;