@allternit/gizzi-code 1.0.0 → 1.0.1

package/src/utils/settings/constants.ts

@@ -0,0 +1,10 @@
+/**
+ * Settings Constants
+ */
+
+export type SettingSource = 'config' | 'env' | 'default'
+
+export const DEFAULT_SETTINGS = {
+  theme: 'default',
+  autoCompact: true,
+}

package/src/utils/settings/settings.ts

@@ -0,0 +1,19 @@
+/**
+ * Settings Utilities
+ */
+
+import type { Settings } from './types.js'
+
+let cachedSettings: Settings = {}
+
+export function getSettings(): Settings {
+  return cachedSettings
+}
+
+export function getInitialSettings(): Settings {
+  return {}
+}
+
+export function updateSettings(settings: Partial<Settings>): void {
+  cachedSettings = { ...cachedSettings, ...settings }
+}

package/src/utils/settings/types.ts

@@ -0,0 +1,18 @@
+/**
+ * Settings Types
+ */
+
+export interface Settings {
+  theme?: string
+  autoCompact?: boolean
+  [key: string]: unknown
+}
+
+export interface PluginHookMatcher {
+  plugin: string
+  hook: string
+}
+
+export interface HooksSettings {
+  [hook: string]: unknown
+}

package/src/utils/shell/shellToolUtils.ts

@@ -0,0 +1,9 @@
+/**
+ * Shell Tool Utilities
+ */
+
+export const SHELL_TOOL_NAMES = {
+  bash: 'BashTool',
+  glob: 'GlobTool',
+  grep: 'GrepTool',
+} as const

package/src/utils/sinks.ts

@@ -0,0 +1,11 @@
+/**
+ * Output Sinks
+ */
+
+export interface Sink {
+  write(data: string): void
+}
+
+export function getSinks(): Sink[] {
+  return []
+}

package/src/utils/sleep.ts

@@ -0,0 +1,7 @@
+/**
+ * Sleep Utility
+ */
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}

package/src/utils/sliceAnsi.ts

@@ -0,0 +1,7 @@
+/**
+ * ANSI String Slicing
+ */
+
+export function sliceAnsi(str: string, start: number, end?: number): string {
+  return str.slice(start, end)
+}

package/src/utils/slowOperations.ts

@@ -0,0 +1,3 @@
+// Re-export from shared/utils
+export * from '../shared/utils/slowOperations.js'
+export { default } from '../shared/utils/slowOperations.js'

package/src/utils/startupProfiler.ts

@@ -0,0 +1,11 @@
+/**
+ * Startup Profiler
+ */
+
+export function profileCheckpoint(label: string): void {
+  // Implementation
+}
+
+export function getStartupProfile(): Record<string, number> {
+  return {}
+}

package/src/utils/stringUtils.ts

@@ -0,0 +1,106 @@
+/**
+ * String utilities
+ * Production implementation with all required exports
+ */
+
+// Escape special regex characters
+export function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+// Capitalize first letter
+export function capitalize(str: string): string {
+  if (!str) return str
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+// Pluralize a word
+export function plural(
+  count: number,
+  singular: string,
+  plural?: string,
+  includeCount = true,
+): string {
+  const p = plural ?? `${singular}s`
+  const word = count === 1 ? singular : p
+  return includeCount ? `${count} ${word}` : word
+}
+
+// Get first line of a string
+export function firstLineOf(s: string): string {
+  const idx = s.indexOf('\n')
+  return idx === -1 ? s : s.slice(0, idx)
+}
+
+// Count occurrences of a character in a string
+export function countCharInString(str: string, char: string): number {
+  let count = 0
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === char) count++
+  }
+  return count
+}
+
+// Normalize full-width digits to ASCII
+export function normalizeFullWidthDigits(input: string): string {
+  return input.replace(/[\uFF10-\uFF19]/g, (c) =>
+    String.fromCharCode(c.charCodeAt(0) - 0xfee0),
+  )
+}
+
+// Normalize full-width space to ASCII space
+export function normalizeFullWidthSpace(input: string): string {
+  return input.replace(/\u3000/g, ' ')
+}
+
+// Join lines with safe handling of undefined values
+export function safeJoinLines(
+  lines: (string | undefined | null)[],
+  separator = '\n',
+): string {
+  return lines.filter((l): l is string => l != null && l !== '').join(separator)
+}
+
+// Truncate text to a maximum number of lines
+export function truncateToLines(text: string, maxLines: number): string {
+  const lines = text.split('\n')
+  if (lines.length <= maxLines) return text
+  return lines.slice(0, maxLines).join('\n') + '\n… (truncated)'
+}
+
+// Truncating accumulator that builds text line by line
+export class EndTruncatingAccumulator {
+  private lines: string[] = []
+  private _truncated = false
+
+  constructor(
+    private maxLines: number,
+    private overflowIndicator = '\n… (truncated)',
+  ) {}
+
+  add(line: string): this {
+    if (!this._truncated) {
+      if (this.lines.length >= this.maxLines) {
+        this._truncated = true
+      } else {
+        this.lines.push(line)
+      }
+    }
+    return this
+  }
+
+  get truncated(): boolean {
+    return this._truncated
+  }
+
+  toString(): string {
+    const lines = this._truncated
+      ? [...this.lines, this.overflowIndicator]
+      : this.lines
+    return lines.join('\n')
+  }
+
+  get lineCount(): number {
+    return this.lines.length
+  }
+}

package/src/utils/systemPromptType.ts

@@ -0,0 +1,9 @@
+/**
+ * System Prompt Type
+ */
+
+export type SystemPrompt = string
+
+export function asSystemPrompt(prompt: string): SystemPrompt {
+  return prompt
+}

package/src/utils/teleport/api.ts

@@ -0,0 +1,15 @@
+/**
+ * Teleport API Utilities
+ */
+
+export interface TeleportApiConfig {
+  baseUrl: string
+  token?: string
+}
+
+export async function teleportRequest<T>(
+  endpoint: string,
+  config?: TeleportApiConfig
+): Promise<T> {
+  return {} as T
+}

package/src/utils/textHighlighting.ts

@@ -0,0 +1,16 @@
+/**
+ * Text Highlighting Utilities
+ */
+
+export interface HighlightOptions {
+  language?: string
+  theme?: string
+}
+
+export function highlightText(text: string, options?: HighlightOptions): string {
+  return text
+}
+
+export function highlightCode(code: string, language?: string): string {
+  return code
+}

package/src/utils/theme.ts

@@ -0,0 +1,17 @@
+/**
+ * Theme Utilities
+ */
+
+export interface Theme {
+  name: string
+  colors: Record<string, string>
+}
+
+export const defaultTheme: Theme = {
+  name: 'default',
+  colors: {},
+}
+
+export function getTheme(): Theme {
+  return defaultTheme
+}

package/src/utils/thinking.ts

@@ -0,0 +1,58 @@
+/**
+ * Thinking/thought process utilities
+ */
+
+export interface Thought {
+  id: string
+  content: string
+  timestamp: number
+  category?: string
+}
+
+export class ThinkingSession {
+  private thoughts: Thought[] = []
+  private isActive = false
+
+  start(): void {
+    this.isActive = true
+    this.thoughts = []
+  }
+
+  stop(): Thought[] {
+    this.isActive = false
+    return [...this.thoughts]
+  }
+
+  addThought(content: string, category?: string): void {
+    if (!this.isActive) return
+    this.thoughts.push({
+      id: `thought_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+      content,
+      timestamp: Date.now(),
+      category,
+    })
+  }
+
+  getThoughts(): Thought[] {
+    return [...this.thoughts]
+  }
+
+  clear(): void {
+    this.thoughts = []
+  }
+
+  isThinking(): boolean {
+    return this.isActive
+  }
+}
+
+export function formatThought(thought: Thought): string {
+  const time = new Date(thought.timestamp).toLocaleTimeString()
+  const category = thought.category ? `[${thought.category}] ` : ''
+  return `${time} ${category}${thought.content}`
+}
+
+export default {
+  ThinkingSession,
+  formatThought,
+}

package/src/utils/tokens.ts

@@ -0,0 +1,11 @@
+/**
+ * Token Utilities
+ */
+
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4)
+}
+
+export function countTokens(text: string): number {
+  return estimateTokens(text)
+}

package/src/utils/toolResultStorage.ts

@@ -0,0 +1,17 @@
+/**
+ * Tool Result Storage
+ */
+
+export interface ToolResultEntry {
+  tool: string
+  result: unknown
+  timestamp: number
+}
+
+export async function storeToolResult(entry: ToolResultEntry): Promise<void> {
+  // Implementation
+}
+
+export async function getToolResults(tool: string): Promise<ToolResultEntry[]> {
+  return []
+}

package/src/utils/worktreeModeEnabled.ts

@@ -0,0 +1,7 @@
+/**
+ * Worktree Mode Check
+ */
+
+export function isWorktreeModeEnabled(): boolean {
+  return false
+}

package/WORKSPACE_INTEGRATION.md

@@ -1,290 +0,0 @@
-# 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