@allternit/gizzi-code 1.0.0 → 1.0.1

package/src/utils/fullscreen.ts

@@ -1,382 +1,72 @@
 /**
- * @fileoverview Fullscreen utilities for gizzi-code integration
- * @module utils/fullscreen
- *
- * Provides utilities for managing fullscreen mode in browser environments.
- * Includes support for the standard Fullscreen API with vendor prefixes
- * for cross-browser compatibility.
+ * Fullscreen utilities
  */
 
-/**
- * Fullscreen change event handler type
- * @typedef {Function} FullscreenChangeHandler
- */
-export type FullscreenChangeHandler = (isFullscreen: boolean) => void;
-
-/**
- * Extended document interface with vendor-prefixed fullscreen properties
- * @interface FullscreenDocument
- */
-interface FullscreenDocument extends Document {
-  readonly webkitFullscreenElement?: Element | null;
-  readonly mozFullScreenElement?: Element | null;
-  readonly msFullscreenElement?: Element | null;
-  readonly webkitIsFullScreen?: boolean;
-  readonly mozFullScreen?: boolean;
-  readonly msIsFullScreen?: boolean;
-  webkitExitFullscreen?: () => Promise<void>;
-  mozCancelFullScreen?: () => Promise<void>;
-  msExitFullscreen?: () => Promise<void>;
-}
-
-/**
- * Extended HTML element interface with vendor-prefixed fullscreen methods
- * @interface FullscreenElement
- */
-interface FullscreenElement extends HTMLElement {
-  webkitRequestFullscreen?: (options?: FullscreenOptions) => Promise<void>;
-  mozRequestFullScreen?: (options?: FullscreenOptions) => Promise<void>;
-  msRequestFullscreen?: () => Promise<void>;
-}
-
-/**
- * Checks if the Fullscreen API is supported in the current environment
- *
- * @returns {boolean} True if fullscreen is supported
- * @example
- * ```typescript
- * if (isFullscreenSupported()) {
- *   enterFullscreen();
- * }
- * ```
- */
-export function isFullscreenSupported(): boolean {
-  if (typeof document === 'undefined') {
-    return false;
+export function enterFullscreen(): Promise<void> {
+  if (typeof process !== 'undefined' && process.stdout) {
+    // Terminal fullscreen escape sequence
+    process.stdout.write('\x1b[?1049h')
+    return Promise.resolve()
   }
-
-  const doc = document as FullscreenDocument;
-  const elem = document.documentElement as FullscreenElement;
-
-  return !!(
-    doc.fullscreenEnabled ??
-    (doc as unknown as { webkitFullscreenEnabled?: boolean }).webkitFullscreenEnabled ??
-    (doc as unknown as { mozFullScreenEnabled?: boolean }).mozFullScreenEnabled ??
-    (doc as unknown as { msFullscreenEnabled?: boolean }).msFullscreenEnabled ??
-    elem.requestFullscreen ??
-    elem.webkitRequestFullscreen ??
-    elem.mozRequestFullScreen ??
-    elem.msRequestFullscreen
-  );
+  return Promise.reject(new Error('Fullscreen not supported'))
 }
 
-/**
- * Checks if the document is currently in fullscreen mode
- *
- * @returns {boolean} True if currently in fullscreen
- * @example
- * ```typescript
- * if (isFullscreen()) {
- *   console.log('Currently in fullscreen mode');
- * }
- * ```
- */
-export function isFullscreen(): boolean {
-  if (typeof document === 'undefined') {
-    return false;
+export function exitFullscreen(): Promise<void> {
+  if (typeof process !== 'undefined' && process.stdout) {
+    // Exit terminal fullscreen
+    process.stdout.write('\x1b[?1049l')
+    return Promise.resolve()
   }
-
-  const doc = document as FullscreenDocument;
-
-  return !!(
-    doc.fullscreenElement ??
-    doc.webkitFullscreenElement ??
-    doc.mozFullScreenElement ??
-    doc.msFullscreenElement ??
-    doc.webkitIsFullScreen ??
-    doc.mozFullScreen ??
-    doc.msIsFullScreen
-  );
+  return Promise.reject(new Error('Fullscreen not supported'))
 }
 
-/**
- * Enters fullscreen mode for the specified element or document
- *
- * @param {HTMLElement} [element] - Element to make fullscreen (defaults to document.documentElement)
- * @param {FullscreenOptions} [options] - Fullscreen options
- * @returns {Promise<void>} Promise that resolves when fullscreen is entered
- * @throws {Error} If fullscreen is not supported or permission is denied
- * @example
- * ```typescript
- * // Make entire page fullscreen
- * await enterFullscreen();
- *
- * // Make specific element fullscreen
- * const video = document.getElementById('myVideo');
- * await enterFullscreen(video);
- *
- * // With navigation UI hidden
- * await enterFullscreen(undefined, { navigationUI: 'hide' });
- * ```
- */
-export async function enterFullscreen(
-  element?: HTMLElement,
-  options?: FullscreenOptions
-): Promise<void> {
-  if (typeof document === 'undefined') {
-    return Promise.reject(new Error('Fullscreen not available in server environment'));
-  }
-
-  const target = (element ?? document.documentElement) as FullscreenElement;
-
-  // Try standard method first
-  if (target.requestFullscreen) {
-    return target.requestFullscreen(options);
-  }
-
-  // Vendor prefixed fallbacks
-  if (target.webkitRequestFullscreen) {
-    return target.webkitRequestFullscreen(options);
-  }
-
-  if (target.mozRequestFullScreen) {
-    return target.mozRequestFullScreen(options);
-  }
-
-  if (target.msRequestFullscreen) {
-    return target.msRequestFullscreen();
-  }
-
-  throw new Error('Fullscreen API is not supported in this browser');
+export function isFullscreen(): boolean {
+  // In terminal context, we can't reliably detect fullscreen
+  return false
 }
 
-/**
- * Exits fullscreen mode
- *
- * @returns {Promise<void>} Promise that resolves when fullscreen is exited
- * @throws {Error} If not in fullscreen or API not supported
- * @example
- * ```typescript
- * await exitFullscreen();
- * console.log('Exited fullscreen');
- * ```
- */
-export async function exitFullscreen(): Promise<void> {
-  if (typeof document === 'undefined') {
-    return Promise.reject(new Error('Fullscreen not available in server environment'));
-  }
-
-  if (!isFullscreen()) {
-    return Promise.resolve();
-  }
-
-  const doc = document as FullscreenDocument;
-
-  // Try standard method first
-  if (document.exitFullscreen) {
-    return document.exitFullscreen();
-  }
-
-  // Vendor prefixed fallbacks
-  if (doc.webkitExitFullscreen) {
-    return doc.webkitExitFullscreen();
-  }
-
-  if (doc.mozCancelFullScreen) {
-    return doc.mozCancelFullScreen();
-  }
-
-  if (doc.msExitFullscreen) {
-    return doc.msExitFullscreen();
-  }
-
-  throw new Error('Fullscreen API is not supported in this browser');
+export function toggleFullscreen(): Promise<void> {
+  return isFullscreen() ? exitFullscreen() : enterFullscreen()
 }
 
-/**
- * Toggles fullscreen mode for the specified element
- *
- * @param {HTMLElement} [element] - Element to toggle (defaults to document.documentElement)
- * @param {FullscreenOptions} [options] - Fullscreen options
- * @returns {Promise<boolean>} Promise that resolves to new fullscreen state
- * @example
- * ```typescript
- * const isFullscreen = await toggleFullscreen();
- * console.log('Fullscreen active:', isFullscreen);
- * ```
- */
-export async function toggleFullscreen(
-  element?: HTMLElement,
-  options?: FullscreenOptions
-): Promise<boolean> {
-  if (isFullscreen()) {
-    await exitFullscreen();
-    return false;
-  } else {
-    await enterFullscreen(element, options);
-    return true;
+export function clearScreen(): void {
+  if (typeof process !== 'undefined' && process.stdout) {
+    process.stdout.write('\x1b[2J\x1b[H')
   }
 }
 
-/**
- * Subscribes to fullscreen change events
- *
- * @param {FullscreenChangeHandler} handler - Callback fired when fullscreen state changes
- * @returns {() => void} Unsubscribe function
- * @example
- * ```typescript
- * const unsubscribe = onFullscreenChange((isFullscreen) => {
- *   console.log('Fullscreen changed:', isFullscreen);
- * });
- *
- * // Later: unsubscribe();
- * ```
- */
-export function onFullscreenChange(
-  handler: FullscreenChangeHandler
-): () => void {
-  if (typeof document === 'undefined') {
-    return () => {
-      // No-op in server environment
-    };
+export function hideCursor(): void {
+  if (typeof process !== 'undefined' && process.stdout) {
+    process.stdout.write('\x1b[?25l')
   }
-
-  const handleChange = (): void => {
-    handler(isFullscreen());
-  };
-
-  // Standard event
-  document.addEventListener('fullscreenchange', handleChange);
-  // Vendor prefixed events
-  document.addEventListener('webkitfullscreenchange', handleChange);
-  document.addEventListener('mozfullscreenchange', handleChange);
-  document.addEventListener('MSFullscreenChange', handleChange);
-
-  // Return unsubscribe function
-  return () => {
-    document.removeEventListener('fullscreenchange', handleChange);
-    document.removeEventListener('webkitfullscreenchange', handleChange);
-    document.removeEventListener('mozfullscreenchange', handleChange);
-    document.removeEventListener('MSFullscreenChange', handleChange);
-  };
 }
 
-/**
- * Gets the current fullscreen element
- *
- * @returns {Element | null} The element currently in fullscreen, or null
- * @example
- * ```typescript
- * const element = getFullscreenElement();
- * if (element) {
- *   console.log('Fullscreen element:', element.tagName);
- * }
- * ```
- */
-export function getFullscreenElement(): Element | null {
-  if (typeof document === 'undefined') {
-    return null;
+export function showCursor(): void {
+  if (typeof process !== 'undefined' && process.stdout) {
+    process.stdout.write('\x1b[?25h')
   }
-
-  const doc = document as FullscreenDocument;
-
-  return (
-    doc.fullscreenElement ??
-    doc.webkitFullscreenElement ??
-    doc.mozFullScreenElement ??
-    doc.msFullscreenElement ??
-    null
-  );
 }
 
-/**
- * Locks screen orientation when in fullscreen (mobile devices)
- *
- * @param {OrientationLockType} orientation - Orientation to lock to
- * @returns {Promise<void>} Promise that resolves when orientation is locked
- * @example
- * ```typescript
- * await lockOrientation('landscape');
- * await enterFullscreen();
- * ```
- */
-/**
- * Valid orientation lock types
- * @typedef {string} OrientationLockType
- */
-type OrientationLockType = 'any' | 'natural' | 'landscape' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
-
-/**
- * Locks screen orientation when in fullscreen (mobile devices)
- *
- * @param {OrientationLockType} orientation - Orientation to lock to
- * @returns {Promise<void>} Promise that resolves when orientation is locked
- * @example
- * ```typescript
- * await lockOrientation('landscape');
- * await enterFullscreen();
- * ```
- */
-export async function lockOrientation(
-  orientation: OrientationLockType
-): Promise<void> {
-  if (typeof screen === 'undefined' || !screen.orientation) {
-    return Promise.reject(new Error('Screen Orientation API not supported'));
-  }
-
-  // Type assertion for lock method which may not be in all TypeScript lib versions
-  const orientationApi = screen.orientation as {
-    lock?(orientation: OrientationLockType): Promise<void>;
-    unlock?(): void;
-  };
-
-  if (!orientationApi.lock) {
-    return Promise.reject(new Error('Screen orientation lock not supported'));
-  }
-
-  try {
-    await orientationApi.lock(orientation);
-  } catch (error) {
-    return Promise.reject(error);
+export function alternateScreen(): void {
+  if (typeof process !== 'undefined' && process.stdout) {
+    process.stdout.write('\x1b[?1049h')
   }
 }
 
-/**
- * Unlocks screen orientation
- *
- * @returns {Promise<void>} Promise that resolves when orientation is unlocked
- * @example
- * ```typescript
- * await unlockOrientation();
- * ```
- */
-export async function unlockOrientation(): Promise<void> {
-  if (typeof screen === 'undefined' || !screen.orientation) {
-    return Promise.resolve();
-  }
-
-  // Type assertion for unlock method which may not be in all TypeScript lib versions
-  const orientationApi = screen.orientation as {
-    lock?(orientation: OrientationLockType): Promise<void>;
-    unlock?(): void;
-  };
-
-  try {
-    orientationApi.unlock?.();
-  } catch {
-    // Ignore unlock errors
+export function mainScreen(): void {
+  if (typeof process !== 'undefined' && process.stdout) {
+    process.stdout.write('\x1b[?1049l')
   }
 }
 
-// Default export
 export default {
-  isFullscreenSupported,
-  isFullscreen,
   enterFullscreen,
   exitFullscreen,
+  isFullscreen,
   toggleFullscreen,
-  onFullscreenChange,
-  getFullscreenElement,
-  lockOrientation,
-  unlockOrientation,
-};
+  clearScreen,
+  hideCursor,
+  showCursor,
+  alternateScreen,
+  mainScreen,
+}

package/src/utils/git.ts

@@ -0,0 +1,15 @@
+/**
+ * Git Utilities
+ */
+
+export async function getGitRoot(cwd?: string): Promise<string | null> {
+  return null
+}
+
+export async function getBranch(cwd?: string): Promise<string | null> {
+  return null
+}
+
+export async function getIsGit(cwd?: string): Promise<boolean> {
+  return false
+}

package/src/utils/imageResizer.ts

@@ -0,0 +1,30 @@
+/**
+ * Image Resizer Utilities
+ */
+
+export interface ImageResizeOptions {
+  maxWidth?: number
+  maxHeight?: number
+  quality?: number
+}
+
+export async function resizeImage(
+  buffer: Buffer,
+  options: ImageResizeOptions
+): Promise<Buffer> {
+  // Placeholder implementation
+  return buffer
+}
+
+export function createImageMetadataText(
+  dimensions: { width: number; height: number },
+  size: number
+): string {
+  return `Image (${dimensions.width}x${dimensions.height}, ${formatFileSize(size)})`
+}
+
+function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`
+}

package/src/utils/lazySchema.ts

@@ -0,0 +1,9 @@
+/**
+ * Lazy Schema Utilities
+ */
+
+import { z } from 'zod/v4'
+
+export function createLazySchema<T>(schema: z.ZodType<T>): z.ZodType<T> {
+  return schema
+}

package/src/utils/log.ts

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

package/src/utils/markdownConfigLoader.ts

@@ -0,0 +1,12 @@
+/**
+ * Markdown Config Loader
+ */
+
+export interface MarkdownConfig {
+  theme?: string
+  highlight?: boolean
+}
+
+export function loadMarkdownConfig(): MarkdownConfig {
+  return {}
+}

package/src/utils/messages.ts

@@ -0,0 +1,13 @@
+/**
+ * Message Utilities
+ */
+
+import type { Message } from '@/types/message.js'
+
+export function countToolCalls(messages: Message[]): number {
+  return messages.filter(m => m.type === 'tool_use').length
+}
+
+export const SYNTHETIC_MESSAGES = {
+  compact: 'COMPACT',
+} as const

package/src/utils/migration.ts

@@ -0,0 +1,137 @@
+/**
+ * Migration Utilities
+ * 
+ * Handles migration from legacy SDK to Allternit Harness.
+ */
+
+import { Config } from '@/config';
+import { HarnessConfig } from '@allternit/sdk';
+import { getHarnessMode, FEATURE_FLAGS } from './feature-flags';
+
+/**
+ * Migrate existing configuration to harness format.
+ */
+export async function migrateToHarness(): Promise<void> {
+  const mode = getHarnessMode();
+  
+  // Check if already migrated
+  const existingMode = await Config.get('harness.mode');
+  if (existingMode) {
+    return; // Already migrated
+  }
+  
+  // Migrate based on mode
+  switch (mode) {
+    case 'byok':
+      await migrateBYOK();
+      break;
+    case 'cloud':
+      await migrateCloud();
+      break;
+    case 'local':
+      await migrateLocal();
+      break;
+    case 'subprocess':
+      await migrateSubprocess();
+      break;
+  }
+  
+  // Set mode
+  await Config.set('harness.mode', mode);
+}
+
+/**
+ * Migrate BYOK configuration.
+ */
+async function migrateBYOK(): Promise<void> {
+  // Check for existing API keys
+  const anthropicKey = process.env.ANTHROPIC_API_KEY || await Config.get('anthropic.apiKey');
+  const openaiKey = process.env.OPENAI_API_KEY || await Config.get('openai.apiKey');
+  const googleKey = process.env.GOOGLE_API_KEY || await Config.get('google.apiKey');
+  
+  if (anthropicKey) {
+    await Config.set('harness.byok.anthropic.apiKey', anthropicKey);
+  }
+  if (openaiKey) {
+    await Config.set('harness.byok.openai.apiKey', openaiKey);
+  }
+  if (googleKey) {
+    await Config.set('harness.byok.google.apiKey', googleKey);
+  }
+}
+
+/**
+ * Migrate cloud configuration.
+ */
+async function migrateCloud(): Promise<void> {
+  const accessToken = await Config.get('oauth.accessToken') || process.env.ALLTERNIT_ACCESS_TOKEN;
+  
+  if (accessToken) {
+    await Config.set('harness.cloud.accessToken', accessToken);
+    await Config.set('harness.cloud.baseURL', FEATURE_FLAGS.CLOUD_BASE_URL);
+  }
+}
+
+/**
+ * Migrate local configuration.
+ */
+async function migrateLocal(): Promise<void> {
+  await Config.set('harness.local.baseURL', FEATURE_FLAGS.LOCAL_BASE_URL);
+}
+
+/**
+ * Migrate subprocess configuration.
+ */
+async function migrateSubprocess(): Promise<void> {
+  if (FEATURE_FLAGS.SUBPROCESS_CMD) {
+    await Config.set('harness.subprocess.command', FEATURE_FLAGS.SUBPROCESS_CMD);
+  }
+}
+
+/**
+ * Get harness configuration for initialization.
+ */
+export async function getHarnessConfig(): Promise<HarnessConfig> {
+  const mode = getHarnessMode();
+  
+  switch (mode) {
+    case 'byok':
+      return {
+        mode: 'byok',
+        byok: {
+          anthropic: { apiKey: await Config.get('harness.byok.anthropic.apiKey') },
+          openai: { apiKey: await Config.get('harness.byok.openai.apiKey') },
+          google: { apiKey: await Config.get('harness.byok.google.apiKey') },
+        },
+      };
+      
+    case 'cloud':
+      return {
+        mode: 'cloud',
+        cloud: {
+          baseURL: await Config.get('harness.cloud.baseURL') || FEATURE_FLAGS.CLOUD_BASE_URL,
+          accessToken: await Config.get('harness.cloud.accessToken'),
+          refreshToken: await Config.get('harness.cloud.refreshToken'),
+        },
+      };
+      
+    case 'local':
+      return {
+        mode: 'local',
+        local: {
+          baseURL: await Config.get('harness.local.baseURL') || FEATURE_FLAGS.LOCAL_BASE_URL,
+        },
+      };
+      
+    case 'subprocess':
+      return {
+        mode: 'subprocess',
+        subprocess: {
+          command: await Config.get('harness.subprocess.command') || FEATURE_FLAGS.SUBPROCESS_CMD || 'kimi -p',
+        },
+      };
+      
+    default:
+      throw new Error(`Unknown harness mode: ${mode}`);
+  }
+}

package/src/utils/model/providers.ts

@@ -0,0 +1,15 @@
+/**
+ * Model Providers
+ */
+
+export type ModelProvider = 'anthropic' | 'openai' | 'google'
+
+export function getAPIProvider(): ModelProvider {
+  return 'anthropic'
+}
+
+export function getModelProvider(model: string): ModelProvider {
+  if (model.includes('claude')) return 'anthropic'
+  if (model.includes('gpt')) return 'openai'
+  return 'anthropic'
+}

package/src/utils/path.ts

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

package/src/utils/permissions/PermissionResult.ts

@@ -0,0 +1,14 @@
+/**
+ * Permission Result Types
+ */
+
+export type PermissionResult = 
+  | { type: 'allowed' }
+  | { type: 'denied'; reason: string }
+  | { type: 'pending' }
+
+export const PermissionResult = {
+  allowed: (): PermissionResult => ({ type: 'allowed' }),
+  denied: (reason: string): PermissionResult => ({ type: 'denied', reason }),
+  pending: (): PermissionResult => ({ type: 'pending' }),
+}