@allternit/gizzi-code 1.0.0

package/src/hooks/useKeybinding.ts

@@ -0,0 +1,226 @@
+/**
+ * @fileoverview Keybinding hook for gizzi-code integration
+ * @module hooks/useKeybinding
+ *
+ * Provides a React hook for registering keyboard shortcuts and key combinations.
+ * Supports modifier keys (Ctrl, Alt, Shift, Meta) and automatic cleanup on unmount.
+ */
+
+import { useEffect, useCallback, useRef } from 'react';
+
+/**
+ * Key combination configuration
+ * @interface KeybindingConfig
+ */
+export interface KeybindingConfig {
+  /** The main key (e.g., 'c', 'Enter', 'Escape') */
+  readonly key: string;
+  /** Require Ctrl key to be pressed */
+  readonly ctrl?: boolean;
+  /** Require Alt/Option key to be pressed */
+  readonly alt?: boolean;
+  /** Require Shift key to be pressed */
+  readonly shift?: boolean;
+  /** Require Meta/Command key to be pressed */
+  readonly meta?: boolean;
+  /** Prevent default browser behavior */
+  readonly preventDefault?: boolean;
+  /** Stop event propagation */
+  readonly stopPropagation?: boolean;
+}
+
+/**
+ * Mutable version for internal parsing
+ * @interface MutableKeybindingConfig
+ */
+interface MutableKeybindingConfig {
+  key: string;
+  ctrl?: boolean;
+  alt?: boolean;
+  shift?: boolean;
+  meta?: boolean;
+  preventDefault?: boolean;
+  stopPropagation?: boolean;
+}
+
+/**
+ * Normalized key combination string for comparison
+ * @param {KeybindingConfig} config - Keybinding configuration
+ * @returns {string} Normalized key combination string
+ */
+function normalizeKeyCombo(config: KeybindingConfig): string {
+  const parts: string[] = [];
+  if (config.ctrl) parts.push('ctrl');
+  if (config.alt) parts.push('alt');
+  if (config.shift) parts.push('shift');
+  if (config.meta) parts.push('meta');
+  parts.push(config.key.toLowerCase());
+  return parts.join('+');
+}
+
+/**
+ * Parses a keybinding string into a config object
+ *
+ * @param {string} keybinding - Keybinding string (e.g., "Ctrl+C", "Escape", "Ctrl+Shift+A")
+ * @returns {KeybindingConfig} Parsed keybinding configuration
+ * @example
+ * ```typescript
+ * parseKeybinding("Ctrl+C"); // { key: 'c', ctrl: true }
+ * parseKeybinding("Escape"); // { key: 'escape' }
+ * parseKeybinding("Ctrl+Shift+A"); // { key: 'a', ctrl: true, shift: true }
+ * ```
+ */
+export function parseKeybinding(keybinding: string): KeybindingConfig {
+  const parts = keybinding.split('+').map((p) => p.trim().toLowerCase());
+
+  const config: MutableKeybindingConfig = {
+    key: '',
+    ctrl: false,
+    alt: false,
+    shift: false,
+    meta: false,
+  };
+
+  for (const part of parts) {
+    switch (part) {
+      case 'ctrl':
+      case 'control':
+        config.ctrl = true;
+        break;
+      case 'alt':
+      case 'option':
+        config.alt = true;
+        break;
+      case 'shift':
+        config.shift = true;
+        break;
+      case 'meta':
+      case 'cmd':
+      case 'command':
+      case 'win':
+      case 'windows':
+        config.meta = true;
+        break;
+      default:
+        config.key = part;
+        break;
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Key event handler type
+ * @typedef {Function} KeyHandler
+ */
+export type KeyHandler = (event: KeyboardEvent) => void | boolean;
+
+/**
+ * React hook for registering keyboard shortcuts
+ *
+ * Registers a keyboard shortcut that triggers the provided handler when pressed.
+ * Automatically cleans up the event listener when the component unmounts or
+ * when the keybinding changes.
+ *
+ * @param {string | KeybindingConfig} key - Key combination (e.g., "Ctrl+C") or config object
+ * @param {KeyHandler} handler - Function to call when keybinding is triggered
+ * @param {boolean} [enabled=true] - Whether the keybinding is active
+ * @example
+ * ```typescript
+ * // Using string keybinding
+ * useKeybinding('Ctrl+C', () => {
+ *   console.log('Copy!');
+ * });
+ *
+ * // Using config object
+ * useKeybinding({ key: 'k', ctrl: true }, (e) => {
+ *   e.preventDefault();
+ *   console.log('Ctrl+K pressed');
+ * });
+ *
+ * // With conditional enabling
+ * useKeybinding('Escape', handleClose, isModalOpen);
+ * ```
+ */
+export function useKeybinding(
+  key: string | KeybindingConfig,
+  handler: KeyHandler,
+  enabled: boolean = true
+): void {
+  const config = typeof key === 'string' ? parseKeybinding(key) : key;
+  const expectedCombo = normalizeKeyCombo(config);
+  const handlerRef = useRef<KeyHandler>(handler);
+
+  // Keep handler reference up to date without re-registering
+  useEffect(() => {
+    handlerRef.current = handler;
+  }, [handler]);
+
+  const handleKeyDown = useCallback(
+    (event: KeyboardEvent) => {
+      // Check if this key event matches our expected combination
+      const actualCombo = normalizeKeyCombo({
+        key: event.key,
+        ctrl: event.ctrlKey,
+        alt: event.altKey,
+        shift: event.shiftKey,
+        meta: event.metaKey,
+      });
+
+      if (actualCombo === expectedCombo) {
+        if (config.preventDefault) {
+          event.preventDefault();
+        }
+        if (config.stopPropagation) {
+          event.stopPropagation();
+        }
+
+        const result = handlerRef.current(event);
+        // Allow handler to prevent default by returning false
+        if (result === false) {
+          event.preventDefault();
+        }
+      }
+    },
+    [config, expectedCombo]
+  );
+
+  useEffect(() => {
+    if (!enabled || typeof window === 'undefined') {
+      return;
+    }
+
+    window.addEventListener('keydown', handleKeyDown);
+
+    return () => {
+      window.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [enabled, handleKeyDown]);
+}
+
+/**
+ * Hook for registering multiple keybindings at once
+ *
+ * @param {Array<[string | KeybindingConfig, KeyHandler]>} bindings - Array of [keybinding, handler] tuples
+ * @param {boolean} [enabled=true] - Whether all keybindings are active
+ * @example
+ * ```typescript
+ * useKeybindings([
+ *   ['Ctrl+C', handleCopy],
+ *   ['Ctrl+V', handlePaste],
+ *   ['Escape', handleClose],
+ * ]);
+ * ```
+ */
+export function useKeybindings(
+  bindings: Array<[string | KeybindingConfig, KeyHandler]>,
+  enabled: boolean = true
+): void {
+  bindings.forEach(([key, handler]) => {
+    useKeybinding(key, handler, enabled);
+  });
+}
+
+// Default export
+export default useKeybinding;

package/src/hooks/useTerminalSize.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Terminal size hook for gizzi-code integration
+ * @module hooks/useTerminalSize
+ *
+ * Provides a React hook to track terminal dimensions with resize event handling.
+ * Returns the current terminal width and height, defaulting to standard terminal
+ * dimensions when not in a browser environment.
+ */
+/**
+ * Terminal size state interface
+ * @interface TerminalSize
+ */
+export interface TerminalSize {
+    /** Current terminal width in columns */
+    readonly width: number;
+    /** Current terminal height in rows */
+    readonly height: number;
+}
+/**
+ * React hook for tracking terminal size
+ *
+ * Returns the current terminal dimensions and automatically updates
+ * when the window is resized. Uses debouncing to prevent excessive
+ * re-renders during resize operations.
+ *
+ * @returns {TerminalSize} Current terminal width and height
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { width, height } = useTerminalSize();
+ *
+ *   return (
+ *     <div>
+ *       Terminal: {width}×{height}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useTerminalSize(): TerminalSize;
+export default useTerminalSize;

package/src/hooks/useTerminalSize.js

@@ -0,0 +1,90 @@
+/**
+ * @fileoverview Terminal size hook for gizzi-code integration
+ * @module hooks/useTerminalSize
+ *
+ * Provides a React hook to track terminal dimensions with resize event handling.
+ * Returns the current terminal width and height, defaulting to standard terminal
+ * dimensions when not in a browser environment.
+ */
+import { useState, useEffect, useCallback } from 'react';
+/**
+ * Default terminal dimensions (80x24 is standard terminal size)
+ * @constant {TerminalSize}
+ */
+const DEFAULT_TERMINAL_SIZE = {
+    width: 80,
+    height: 24,
+};
+/**
+ * Gets the current terminal size from the window object
+ * Falls back to default dimensions if window is not available
+ *
+ * @returns {TerminalSize} Current terminal dimensions
+ */
+function getTerminalSize() {
+    if (typeof window === 'undefined') {
+        return DEFAULT_TERMINAL_SIZE;
+    }
+    // Estimate columns/rows based on window size and average character dimensions
+    // This is an approximation - actual terminal emulators may vary
+    const avgCharWidth = 8; // pixels per character (approximate)
+    const avgLineHeight = 16; // pixels per line (approximate)
+    const width = Math.max(20, Math.floor(window.innerWidth / avgCharWidth));
+    const height = Math.max(5, Math.floor(window.innerHeight / avgLineHeight));
+    return { width, height };
+}
+/**
+ * React hook for tracking terminal size
+ *
+ * Returns the current terminal dimensions and automatically updates
+ * when the window is resized. Uses debouncing to prevent excessive
+ * re-renders during resize operations.
+ *
+ * @returns {TerminalSize} Current terminal width and height
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { width, height } = useTerminalSize();
+ *
+ *   return (
+ *     <div>
+ *       Terminal: {width}×{height}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useTerminalSize() {
+    const [size, setSize] = useState(getTerminalSize);
+    const handleResize = useCallback(() => {
+        setSize(getTerminalSize());
+    }, []);
+    useEffect(() => {
+        // Check if window is available (SSR safety)
+        if (typeof window === 'undefined') {
+            return;
+        }
+        // Debounced resize handler
+        let resizeTimeout = null;
+        const debouncedHandleResize = () => {
+            if (resizeTimeout) {
+                clearTimeout(resizeTimeout);
+            }
+            resizeTimeout = setTimeout(handleResize, 100);
+        };
+        // Set initial size
+        handleResize();
+        // Add resize listener
+        window.addEventListener('resize', debouncedHandleResize);
+        // Cleanup
+        return () => {
+            window.removeEventListener('resize', debouncedHandleResize);
+            if (resizeTimeout) {
+                clearTimeout(resizeTimeout);
+            }
+        };
+    }, [handleResize]);
+    return size;
+}
+// Default export for convenient importing
+export default useTerminalSize;

package/src/hooks/useTerminalSize.ts

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview Terminal size hook for gizzi-code integration
+ * @module hooks/useTerminalSize
+ *
+ * Provides a React hook to track terminal dimensions with resize event handling.
+ * Returns the current terminal width and height, defaulting to standard terminal
+ * dimensions when not in a browser environment.
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+
+/**
+ * Terminal size state interface
+ * @interface TerminalSize
+ */
+export interface TerminalSize {
+  /** Current terminal width in columns */
+  readonly width: number;
+  /** Current terminal height in rows */
+  readonly height: number;
+}
+
+/**
+ * Default terminal dimensions (80x24 is standard terminal size)
+ * @constant {TerminalSize}
+ */
+const DEFAULT_TERMINAL_SIZE: TerminalSize = {
+  width: 80,
+  height: 24,
+};
+
+/**
+ * Gets the current terminal size from the window object
+ * Falls back to default dimensions if window is not available
+ *
+ * @returns {TerminalSize} Current terminal dimensions
+ */
+function getTerminalSize(): TerminalSize {
+  if (typeof window === 'undefined') {
+    return DEFAULT_TERMINAL_SIZE;
+  }
+
+  // Estimate columns/rows based on window size and average character dimensions
+  // This is an approximation - actual terminal emulators may vary
+  const avgCharWidth = 8; // pixels per character (approximate)
+  const avgLineHeight = 16; // pixels per line (approximate)
+
+  const width = Math.max(20, Math.floor(window.innerWidth / avgCharWidth));
+  const height = Math.max(5, Math.floor(window.innerHeight / avgLineHeight));
+
+  return { width, height };
+}
+
+/**
+ * React hook for tracking terminal size
+ *
+ * Returns the current terminal dimensions and automatically updates
+ * when the window is resized. Uses debouncing to prevent excessive
+ * re-renders during resize operations.
+ *
+ * @returns {TerminalSize} Current terminal width and height
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { width, height } = useTerminalSize();
+ *
+ *   return (
+ *     <div>
+ *       Terminal: {width}×{height}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useTerminalSize(): TerminalSize {
+  const [size, setSize] = useState<TerminalSize>(getTerminalSize);
+
+  const handleResize = useCallback(() => {
+    setSize(getTerminalSize());
+  }, []);
+
+  useEffect(() => {
+    // Check if window is available (SSR safety)
+    if (typeof window === 'undefined') {
+      return;
+    }
+
+    // Debounced resize handler
+    let resizeTimeout: ReturnType<typeof setTimeout> | null = null;
+
+    const debouncedHandleResize = (): void => {
+      if (resizeTimeout) {
+        clearTimeout(resizeTimeout);
+      }
+      resizeTimeout = setTimeout(handleResize, 100);
+    };
+
+    // Set initial size
+    handleResize();
+
+    // Add resize listener
+    window.addEventListener('resize', debouncedHandleResize);
+
+    // Cleanup
+    return () => {
+      window.removeEventListener('resize', debouncedHandleResize);
+      if (resizeTimeout) {
+        clearTimeout(resizeTimeout);
+      }
+    };
+  }, [handleResize]);
+
+  return size;
+}
+
+// Default export for convenient importing
+export default useTerminalSize;

package/src/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Gizzi Code - Main Entry Point
+ *
+ * Workspace-aware AI assistant framework
+ */
+export { AppStateStore, getGlobalStore, setGlobalStore, useAppStateStore, useAppStateSelector, useAppStateActions, } from './state/AppStateStore';
+export type { UserPreferences, UserSession, ConnectionStatus, AppState, AppError, } from './state/AppStateStore';
+export { WorkspaceStateStore, getWorkspaceStore, setWorkspaceStore, } from './state/WorkspaceStateStore';
+export type { WorkspaceFile, TrustTier, ScheduledTask, ToolDefinition, ContextPack, WorkspaceSession, MessageRole, } from './workspace/types';
+export { loadWorkspace, executeStartupTasks, enhanceSessionWithWorkspace, } from './workspace/loader';
+export type { FileSystem, LoadWorkspaceOptions, LoadedWorkspace, } from './workspace/loader';
+export { buildContextPack, buildSystemPrompt, parseSoulMd, parseHeartbeatMd, classifyFile, getStartupTasks, requiresPermission, shouldRefreshContext, } from './context/pack-builder';
+export type { BuildContextPackOptions } from './context/pack-builder';
+export type { Message, MessageRole, UserMessage, AssistantMessage, SystemMessage, TypedMessage, MessageThread, Attachment, AttachmentMimeType, MessageStatus, } from './types/message';
+export { MESSAGE_ROLES, isUserMessage, isAssistantMessage, isSystemMessage, isMessageRole, createMessage, } from './types/message';
+export { useTerminalSize, } from './hooks/useTerminalSize';
+export { useExitOnCtrlCD, } from './hooks/useExitOnCtrlCD';
+export { useKeybinding, } from './hooks/useKeybinding';
+export { TaskScheduler, taskScheduler, } from './scheduler/TaskScheduler';
+export type { TaskFrequency, ScheduledTask, SchedulerJob, } from './scheduler/TaskScheduler';
+export { WorkspaceWatcher, getWorkspaceWatcher, stopAllWatchers, workspaceWatcher, } from './watcher/WorkspaceWatcher';
+export type { FileChange, WatcherOptions, } from './watcher/WorkspaceWatcher';
+export declare const VERSION = "1.0.1";

package/src/index.js

@@ -0,0 +1,24 @@
+/**
+ * Gizzi Code - Main Entry Point
+ *
+ * Workspace-aware AI assistant framework
+ */
+// Core State Management
+export { AppStateStore, getGlobalStore, setGlobalStore, useAppStateStore, useAppStateSelector, useAppStateActions, } from './state/AppStateStore';
+// Workspace State (NEW)
+export { WorkspaceStateStore, getWorkspaceStore, setWorkspaceStore, } from './state/WorkspaceStateStore';
+// Workspace Loader (NEW)
+export { loadWorkspace, executeStartupTasks, enhanceSessionWithWorkspace, } from './workspace/loader';
+// Context Pack Builder (NEW)
+export { buildContextPack, buildSystemPrompt, parseSoulMd, parseHeartbeatMd, classifyFile, getStartupTasks, requiresPermission, shouldRefreshContext, } from './context/pack-builder';
+export { MESSAGE_ROLES, isUserMessage, isAssistantMessage, isSystemMessage, isMessageRole, createMessage, } from './types/message';
+// React Hooks
+export { useTerminalSize, } from './hooks/useTerminalSize';
+export { useExitOnCtrlCD, } from './hooks/useExitOnCtrlCD';
+export { useKeybinding, } from './hooks/useKeybinding';
+// Task Scheduler (NEW)
+export { TaskScheduler, taskScheduler, } from './scheduler/TaskScheduler';
+// Workspace Watcher (NEW)
+export { WorkspaceWatcher, getWorkspaceWatcher, stopAllWatchers, workspaceWatcher, } from './watcher/WorkspaceWatcher';
+// Version
+export const VERSION = '1.0.1';

package/src/index.ts

@@ -0,0 +1,132 @@
+/**
+ * Gizzi Code - Main Entry Point
+ * 
+ * Workspace-aware AI assistant framework
+ */
+
+// Core State Management
+export {
+  AppStateStore,
+  getGlobalStore,
+  setGlobalStore,
+  useAppStateStore,
+  useAppStateSelector,
+  useAppStateActions,
+} from './state/AppStateStore';
+
+export type {
+  UserPreferences,
+  UserSession,
+  ConnectionStatus,
+  AppState,
+  AppError,
+} from './state/AppStateStore';
+
+// Workspace State (NEW)
+export {
+  WorkspaceStateStore,
+  getWorkspaceStore,
+  setWorkspaceStore,
+} from './state/WorkspaceStateStore';
+
+// Workspace Types (NEW)
+export type {
+  WorkspaceFile,
+  TrustTier,
+  ScheduledTask,
+  ToolDefinition,
+  ContextPack,
+  WorkspaceSession,
+  MessageRole,
+} from './workspace/types';
+
+// Workspace Loader (NEW)
+export {
+  loadWorkspace,
+  executeStartupTasks,
+  enhanceSessionWithWorkspace,
+} from './workspace/loader';
+
+export type {
+  FileSystem,
+  LoadWorkspaceOptions,
+  LoadedWorkspace,
+} from './workspace/loader';
+
+// Context Pack Builder (NEW)
+export {
+  buildContextPack,
+  buildSystemPrompt,
+  parseSoulMd,
+  parseHeartbeatMd,
+  classifyFile,
+  getStartupTasks,
+  requiresPermission,
+  shouldRefreshContext,
+} from './context/pack-builder';
+
+export type { BuildContextPackOptions } from './context/pack-builder';
+
+// Message Types
+export type {
+  Message,
+  MessageRole,
+  UserMessage,
+  AssistantMessage,
+  SystemMessage,
+  TypedMessage,
+  MessageThread,
+  Attachment,
+  AttachmentMimeType,
+  MessageStatus,
+} from './types/message';
+
+export {
+  MESSAGE_ROLES,
+  isUserMessage,
+  isAssistantMessage,
+  isSystemMessage,
+  isMessageRole,
+  createMessage,
+} from './types/message';
+
+// React Hooks
+export {
+  useTerminalSize,
+} from './hooks/useTerminalSize';
+
+export {
+  useExitOnCtrlCD,
+} from './hooks/useExitOnCtrlCD';
+
+export {
+  useKeybinding,
+} from './hooks/useKeybinding';
+
+// Task Scheduler (NEW)
+export {
+  TaskScheduler,
+  taskScheduler,
+} from './scheduler/TaskScheduler';
+
+export type {
+  TaskFrequency,
+  ScheduledTask,
+  SchedulerJob,
+} from './scheduler/TaskScheduler';
+
+// Workspace Watcher (NEW)
+export {
+  WorkspaceWatcher,
+  getWorkspaceWatcher,
+  stopAllWatchers,
+  workspaceWatcher,
+} from './watcher/WorkspaceWatcher';
+
+export type {
+  FileChange,
+  WatcherOptions,
+} from './watcher/WorkspaceWatcher';
+
+// Version
+export const VERSION = '1.0.1';