@allternit/gizzi-code 1.0.0 → 1.0.1

package/src/utils/claudeInChrome/mcpServer.ts

@@ -0,0 +1,15 @@
+/**
+ * Claude in Chrome MCP Server
+ */
+
+export interface ChromeMcpServer {
+  start(): Promise<void>
+  stop(): Promise<void>
+}
+
+export function createChromeMcpServer(): ChromeMcpServer {
+  return {
+    start: async () => {},
+    stop: async () => {},
+  }
+}

package/src/utils/computerUse/common.ts

@@ -0,0 +1,19 @@
+/**
+ * Computer Use Common Utilities
+ */
+
+export interface ComputerUseConfig {
+  enabled: boolean
+  timeout?: number
+}
+
+export function getComputerUseConfig(): ComputerUseConfig {
+  return { enabled: false }
+}
+
+export async function executeComputerAction(
+  action: string,
+  config?: ComputerUseConfig
+): Promise<string> {
+  return ''
+}

package/src/utils/computerUse/mcpServer.ts

@@ -0,0 +1,15 @@
+/**
+ * Computer Use MCP Server
+ */
+
+export interface ComputerUseMcpServer {
+  start(): Promise<void>
+  stop(): Promise<void>
+}
+
+export function createComputerUseMcpServer(): ComputerUseMcpServer {
+  return {
+    start: async () => {},
+    stop: async () => {},
+  }
+}

package/src/utils/config.ts

@@ -0,0 +1,35 @@
+/**
+ * Config Utilities
+ */
+
+export interface Config {
+  [key: string]: unknown
+}
+
+export function getConfig(): Config {
+  return {}
+}
+
+export function setConfig(key: string, value: unknown): void {
+  // Implementation
+}
+
+// Global config for buddy/companion
+export interface GlobalConfig {
+  theme?: string
+  notifications?: boolean
+  autoUpdate?: boolean
+  telemetry?: boolean
+  debug?: boolean
+  [key: string]: unknown
+}
+
+let globalConfig: GlobalConfig = {}
+
+export function getGlobalConfig(): GlobalConfig {
+  return globalConfig
+}
+
+export function setGlobalConfig(config: GlobalConfig): void {
+  globalConfig = { ...globalConfig, ...config }
+}

package/src/utils/context.ts

@@ -0,0 +1,19 @@
+/**
+ * Context Utilities
+ */
+
+export interface Context {
+  sessionId?: string
+  projectId?: string
+  cwd: string
+}
+
+let currentContext: Context = { cwd: process.cwd() }
+
+export function getContext(): Context {
+  return currentContext
+}
+
+export function setContext(ctx: Partial<Context>): void {
+  currentContext = { ...currentContext, ...ctx }
+}

package/src/utils/cwd.ts

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

package/src/utils/debug.ts

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

package/src/utils/earlyInput.ts

@@ -0,0 +1,7 @@
+/**
+ * Early Input Handler
+ */
+
+export function getEarlyInput(): string {
+  return ''
+}

package/src/utils/effort.ts

@@ -0,0 +1,13 @@
+/**
+ * Effort Level Utilities
+ */
+
+export type EffortLevel = 'low' | 'medium' | 'high' | 'max'
+
+export function getEffortLevel(): EffortLevel {
+  return 'medium'
+}
+
+export function setEffortLevel(level: EffortLevel): void {
+  // Implementation
+}

package/src/utils/embeddedTools.ts

@@ -0,0 +1,12 @@
+/**
+ * Embedded Tools Utilities
+ */
+
+export interface EmbeddedTool {
+  name: string
+  code: string
+}
+
+export function getEmbeddedTools(): EmbeddedTool[] {
+  return []
+}

package/src/utils/envUtils.ts

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

package/src/utils/errors.ts

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

package/src/utils/execFileNoThrow.ts

@@ -0,0 +1,24 @@
+/**
+ * Exec File without throwing
+ */
+
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+
+const execFileAsync = promisify(execFile)
+
+export async function execFileNoThrow(
+  command: string,
+  args?: string[]
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, args)
+    return { stdout, stderr, exitCode: 0 }
+  } catch (error: any) {
+    return {
+      stdout: error.stdout || '',
+      stderr: error.stderr || '',
+      exitCode: error.code || 1,
+    }
+  }
+}

package/src/utils/feature-flags.ts

@@ -0,0 +1,112 @@
+/**
+ * Feature Flags
+ * 
+ * Centralized feature flag management for Gizzi Code.
+ */
+
+export const FEATURE_FLAGS = {
+  /**
+   * Enable the Allternit Harness for AI interactions.
+   * When enabled, uses @allternit/sdk with system prompt injection.
+   * When disabled, uses legacy direct SDK calls.
+   */
+  USE_HARNESS: process.env.GIZZI_USE_HARNESS === '1' || process.env.GIZZI_USE_HARNESS === 'true',
+  
+  /**
+   * Harness operating mode.
+   * - 'byok': Bring Your Own Key (direct to providers)
+   * - 'cloud': Use Allternit cloud gateway
+   * - 'local': Local Ollama server
+   * - 'subprocess': CLI subprocess (e.g., kimi -p)
+   */
+  HARNESS_MODE: (process.env.GIZZI_HARNESS_MODE || 'byok') as 'byok' | 'cloud' | 'local' | 'subprocess',
+  
+  /**
+   * Subprocess command for subprocess mode.
+   * Example: "kimi -p", "claude -p", "llm -m gpt-4"
+   */
+  SUBPROCESS_CMD: process.env.GIZZI_SUBPROCESS_CMD || '',
+  
+  /**
+   * Base URL for local mode.
+   * Default: http://localhost:11434 (Ollama)
+   */
+  LOCAL_BASE_URL: process.env.GIZZI_LOCAL_BASE_URL || 'http://localhost:11434',
+  
+  /**
+   * Cloud gateway URL.
+   * Default: https://api.allternit.com
+   */
+  CLOUD_BASE_URL: process.env.GIZZI_CLOUD_BASE_URL || 'https://api.allternit.com',
+};
+
+/**
+ * Check if harness mode is enabled.
+ */
+export function shouldUseHarness(): boolean {
+  return FEATURE_FLAGS.USE_HARNESS;
+}
+
+/**
+ * Get the configured harness mode.
+ */
+export function getHarnessMode(): 'byok' | 'cloud' | 'local' | 'subprocess' {
+  return FEATURE_FLAGS.HARNESS_MODE;
+}
+
+/**
+ * Check if a specific feature is enabled.
+ */
+export function isFeatureEnabled(feature: keyof typeof FEATURE_FLAGS): boolean {
+  const value = FEATURE_FLAGS[feature];
+  return typeof value === 'boolean' ? value : Boolean(value);
+}
+
+/**
+ * Get the harness configuration based on environment.
+ */
+export async function getHarnessConfig() {
+  const mode = FEATURE_FLAGS.HARNESS_MODE;
+  
+  switch (mode) {
+    case 'byok':
+      return {
+        mode: 'byok' as const,
+        byok: {
+          keys: {
+            anthropic: process.env.ANTHROPIC_API_KEY || '',
+            openai: process.env.OPENAI_API_KEY || '',
+            google: process.env.GOOGLE_API_KEY || '',
+          },
+        },
+      };
+      
+    case 'cloud':
+      return {
+        mode: 'cloud' as const,
+        cloud: {
+          baseURL: FEATURE_FLAGS.CLOUD_BASE_URL,
+          accessToken: process.env.ALLTERNIT_ACCESS_TOKEN || '',
+        },
+      };
+      
+    case 'local':
+      return {
+        mode: 'local' as const,
+        local: {
+          baseURL: FEATURE_FLAGS.LOCAL_BASE_URL,
+        },
+      };
+      
+    case 'subprocess':
+      return {
+        mode: 'subprocess' as const,
+        subprocess: {
+          command: FEATURE_FLAGS.SUBPROCESS_CMD || 'kimi -p',
+        },
+      };
+      
+    default:
+      throw new Error(`Unknown harness mode: ${mode}`);
+  }
+}

package/src/utils/file.ts

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

package/src/utils/fileHistory.ts

@@ -0,0 +1,17 @@
+/**
+ * File History Tracking
+ */
+
+export interface FileHistoryEntry {
+  path: string
+  timestamp: number
+  content?: string
+}
+
+export async function getFileHistory(path: string): Promise<FileHistoryEntry[]> {
+  return []
+}
+
+export async function addFileHistoryEntry(entry: FileHistoryEntry): Promise<void> {
+  // Implementation
+}

package/src/utils/fingerprint.ts

@@ -0,0 +1,7 @@
+/**
+ * Device Fingerprint Utilities
+ */
+
+export async function getFingerprint(): Promise<string> {
+  return 'default-fingerprint'
+}