@automagik/genie 0.260201.2240

package/src/lib/api-client.ts

@@ -0,0 +1,109 @@
+export interface Model {
+  id: string;
+  created: number;
+  owned_by: string;
+}
+
+export interface ModelsResponse {
+  data: Model[];
+  object: string;
+}
+
+export type ConnectionResult =
+  | { success: true; modelCount: number; models: Model[] }
+  | { success: false; error: 'auth_failure' | 'network_error' | 'invalid_url' | 'unknown'; message: string };
+
+export async function testConnection(apiUrl: string, apiKey: string): Promise<ConnectionResult> {
+  try {
+    // Validate URL format
+    try {
+      new URL(apiUrl);
+    } catch {
+      return {
+        success: false,
+        error: 'invalid_url',
+        message: `Invalid URL format: ${apiUrl}`,
+      };
+    }
+
+    const response = await fetch(`${apiUrl}/v1/models`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      return {
+        success: false,
+        error: 'auth_failure',
+        message: 'Authentication failed. Check your API key.',
+      };
+    }
+
+    if (!response.ok) {
+      return {
+        success: false,
+        error: 'unknown',
+        message: `Server returned ${response.status}: ${response.statusText}`,
+      };
+    }
+
+    const data = await response.json() as ModelsResponse;
+    const models = data.data || [];
+
+    return {
+      success: true,
+      modelCount: models.length,
+      models,
+    };
+  } catch (error: any) {
+    // Network errors (connection refused, timeout, DNS failure, etc.)
+    if (error.cause?.code === 'ECONNREFUSED' || error.message?.includes('ECONNREFUSED')) {
+      return {
+        success: false,
+        error: 'network_error',
+        message: `Connection refused. Is the server running at ${apiUrl}?`,
+      };
+    }
+    if (error.cause?.code === 'ENOTFOUND' || error.message?.includes('ENOTFOUND')) {
+      return {
+        success: false,
+        error: 'network_error',
+        message: `Could not resolve hostname. Check the URL: ${apiUrl}`,
+      };
+    }
+    if (error.name === 'AbortError' || error.message?.includes('timeout')) {
+      return {
+        success: false,
+        error: 'network_error',
+        message: 'Connection timed out. Check your network and the server URL.',
+      };
+    }
+    return {
+      success: false,
+      error: 'network_error',
+      message: `Network error: ${error.message || 'Unknown error'}`,
+    };
+  }
+}
+
+export async function getModels(apiUrl: string, apiKey: string): Promise<Model[]> {
+  const result = await testConnection(apiUrl, apiKey);
+  if (result.success) {
+    return result.models;
+  }
+  throw new Error(result.message);
+}
+
+export async function validateApiKeyAndGetModels(
+  apiUrl: string,
+  apiKey: string
+): Promise<Model[] | null> {
+  const result = await testConnection(apiUrl, apiKey);
+  if (result.success) {
+    return result.models;
+  }
+  return null;
+}

package/src/lib/claude-settings.ts

@@ -0,0 +1,252 @@
+/**
+ * Claude Settings Manager
+ *
+ * Manages ~/.claude/settings.json without breaking existing settings.
+ * Uses Zod with passthrough() to preserve unknown fields.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { z } from 'zod';
+
+// Claude directory and settings file paths
+const CLAUDE_DIR = join(homedir(), '.claude');
+const CLAUDE_HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
+const CLAUDE_SETTINGS_FILE = join(CLAUDE_DIR, 'settings.json');
+
+// Hook entry schema for a single hook command
+const HookCommandSchema = z.object({
+  type: z.literal('command'),
+  command: z.string(),
+  timeout: z.number().optional(),
+}).passthrough();
+
+// Matcher hooks schema (array of hook commands for a specific matcher)
+const MatcherHooksSchema = z.object({
+  matcher: z.string(),
+  hooks: z.array(HookCommandSchema),
+}).passthrough();
+
+// Hooks configuration schema
+const HooksConfigSchema = z.object({
+  PreToolUse: z.array(MatcherHooksSchema).optional(),
+  PostToolUse: z.array(MatcherHooksSchema).optional(),
+}).passthrough();
+
+// Full settings schema with passthrough to preserve unknown fields
+const ClaudeSettingsSchema = z.object({
+  model: z.string().optional(),
+  enabledPlugins: z.record(z.unknown()).optional(),
+  hooks: HooksConfigSchema.optional(),
+}).passthrough();
+
+export type ClaudeSettings = z.infer<typeof ClaudeSettingsSchema>;
+
+// Constants for the genie hook
+export const GENIE_HOOK_SCRIPT_NAME = 'genie-bash-hook.sh';
+export const GENIE_HOOK_MATCHER = 'Bash';
+
+/**
+ * Get the path to the Claude directory (~/.claude)
+ */
+export function getClaudeDir(): string {
+  return CLAUDE_DIR;
+}
+
+/**
+ * Get the path to the Claude hooks directory (~/.claude/hooks)
+ */
+export function getClaudeHooksDir(): string {
+  return CLAUDE_HOOKS_DIR;
+}
+
+/**
+ * Get the path to the Claude settings file (~/.claude/settings.json)
+ */
+export function getClaudeSettingsPath(): string {
+  return CLAUDE_SETTINGS_FILE;
+}
+
+/**
+ * Get the path to the genie hook script
+ */
+export function getGenieHookScriptPath(): string {
+  return join(CLAUDE_HOOKS_DIR, GENIE_HOOK_SCRIPT_NAME);
+}
+
+/**
+ * Check if Claude settings file exists
+ */
+export function claudeSettingsExists(): boolean {
+  return existsSync(CLAUDE_SETTINGS_FILE);
+}
+
+/**
+ * Ensure the Claude directory exists
+ */
+export function ensureClaudeDir(): void {
+  if (!existsSync(CLAUDE_DIR)) {
+    mkdirSync(CLAUDE_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Ensure the Claude hooks directory exists
+ */
+export function ensureClaudeHooksDir(): void {
+  ensureClaudeDir();
+  if (!existsSync(CLAUDE_HOOKS_DIR)) {
+    mkdirSync(CLAUDE_HOOKS_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load Claude settings, returning defaults if not found
+ */
+export async function loadClaudeSettings(): Promise<ClaudeSettings> {
+  if (!existsSync(CLAUDE_SETTINGS_FILE)) {
+    return ClaudeSettingsSchema.parse({});
+  }
+
+  try {
+    const content = readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8');
+    const data = JSON.parse(content);
+    return ClaudeSettingsSchema.parse(data);
+  } catch (error: any) {
+    // If settings are invalid, return defaults but warn
+    console.warn(`Warning: Invalid Claude settings, using defaults: ${error.message}`);
+    return ClaudeSettingsSchema.parse({});
+  }
+}
+
+/**
+ * Save Claude settings to disk
+ */
+export async function saveClaudeSettings(settings: ClaudeSettings): Promise<void> {
+  ensureClaudeDir();
+
+  try {
+    const validated = ClaudeSettingsSchema.parse(settings);
+    const content = JSON.stringify(validated, null, 2);
+    writeFileSync(CLAUDE_SETTINGS_FILE, content, 'utf-8');
+  } catch (error: any) {
+    throw new Error(`Failed to save Claude settings: ${error.message}`);
+  }
+}
+
+/**
+ * Create the genie hook entry for Claude settings
+ */
+function createGenieHookEntry(scriptPath: string): z.infer<typeof MatcherHooksSchema> {
+  return {
+    matcher: GENIE_HOOK_MATCHER,
+    hooks: [
+      {
+        type: 'command',
+        command: scriptPath,
+        timeout: 600,
+      },
+    ],
+  };
+}
+
+/**
+ * Check if the genie hook is installed in the settings
+ */
+export function isGenieHookInstalled(settings: ClaudeSettings): boolean {
+  const preToolUse = settings.hooks?.PreToolUse;
+  if (!preToolUse || !Array.isArray(preToolUse)) {
+    return false;
+  }
+
+  return preToolUse.some((entry) => {
+    if (entry.matcher !== GENIE_HOOK_MATCHER) return false;
+    if (!Array.isArray(entry.hooks)) return false;
+    return entry.hooks.some((hook) =>
+      hook.type === 'command' && hook.command?.includes(GENIE_HOOK_SCRIPT_NAME)
+    );
+  });
+}
+
+/**
+ * Add the genie hook to Claude settings
+ * Returns the modified settings (does not save to disk)
+ */
+export function addGenieHook(settings: ClaudeSettings): ClaudeSettings {
+  const scriptPath = getGenieHookScriptPath();
+  const hookEntry = createGenieHookEntry(scriptPath);
+
+  // Initialize hooks structure if needed
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks.PreToolUse) {
+    settings.hooks.PreToolUse = [];
+  }
+
+  // Check if already installed
+  if (isGenieHookInstalled(settings)) {
+    return settings;
+  }
+
+  // Remove any existing Bash matcher entries that might conflict
+  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+    (entry) => !(entry.matcher === GENIE_HOOK_MATCHER &&
+      entry.hooks?.some((h) => h.command?.includes('genie')))
+  );
+
+  // Add the new hook entry
+  settings.hooks.PreToolUse.push(hookEntry);
+
+  return settings;
+}
+
+/**
+ * Remove the genie hook from Claude settings
+ * Returns the modified settings (does not save to disk)
+ */
+export function removeGenieHook(settings: ClaudeSettings): ClaudeSettings {
+  if (!settings.hooks?.PreToolUse) {
+    return settings;
+  }
+
+  // Filter out genie hook entries
+  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter((entry) => {
+    // Keep entries that don't match our hook
+    if (entry.matcher !== GENIE_HOOK_MATCHER) return true;
+    if (!Array.isArray(entry.hooks)) return true;
+
+    // Remove entries that have genie hook commands
+    const hasGenieHook = entry.hooks.some((hook) =>
+      hook.type === 'command' && hook.command?.includes(GENIE_HOOK_SCRIPT_NAME)
+    );
+    return !hasGenieHook;
+  });
+
+  // Clean up empty PreToolUse array
+  if (settings.hooks.PreToolUse.length === 0) {
+    delete settings.hooks.PreToolUse;
+  }
+
+  // Clean up empty hooks object
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  return settings;
+}
+
+/**
+ * Contract home directory to ~ in a path (for display)
+ */
+export function contractClaudePath(path: string): string {
+  const home = homedir();
+  if (path.startsWith(home + '/')) {
+    return '~' + path.slice(home.length);
+  }
+  if (path === home) {
+    return '~';
+  }
+  return path;
+}

package/src/lib/config.ts

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { Config, ConfigSchema, Profile } from '../types/config.js';
+
+const CONFIG_DIR = join(homedir(), '.claudio');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}
+
+export function configExists(): boolean {
+  return existsSync(CONFIG_FILE);
+}
+
+export async function loadConfig(): Promise<Config> {
+  if (!existsSync(CONFIG_FILE)) {
+    throw new Error('Config file not found. Run "claudio setup" first.');
+  }
+
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    const data = JSON.parse(content);
+    return ConfigSchema.parse(data);
+  } catch (error: any) {
+    throw new Error(`Failed to load config: ${error.message}`);
+  }
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+
+  try {
+    const validated = ConfigSchema.parse(config);
+    const content = JSON.stringify(validated, null, 2);
+    writeFileSync(CONFIG_FILE, content, 'utf-8');
+  } catch (error: any) {
+    throw new Error(`Failed to save config: ${error.message}`);
+  }
+}
+
+export async function deleteConfig(): Promise<void> {
+  if (existsSync(CONFIG_FILE)) {
+    unlinkSync(CONFIG_FILE);
+  }
+}
+
+export function getDefaultApiUrl(): string {
+  return 'http://10.114.1.119:8317';
+}
+
+export function getAnthropicApiUrl(): string {
+  return 'https://api.anthropic.com/v1';
+}
+
+// Profile CRUD helpers
+
+export async function getDefaultProfile(): Promise<string | undefined> {
+  const config = await loadConfig();
+  return config.defaultProfile;
+}
+
+export async function setDefaultProfile(name: string): Promise<void> {
+  const config = await loadConfig();
+  if (!config.profiles[name]) {
+    throw new Error(`Profile "${name}" not found`);
+  }
+  config.defaultProfile = name;
+  await saveConfig(config);
+}
+
+export async function addProfile(name: string, profile: Profile): Promise<void> {
+  const config = await loadConfig();
+  if (config.profiles[name]) {
+    throw new Error(`Profile "${name}" already exists`);
+  }
+  config.profiles[name] = profile;
+  await saveConfig(config);
+}
+
+export async function removeProfile(name: string): Promise<void> {
+  const config = await loadConfig();
+  if (!config.profiles[name]) {
+    throw new Error(`Profile "${name}" not found`);
+  }
+  delete config.profiles[name];
+  // Clear default if we just deleted it
+  if (config.defaultProfile === name) {
+    config.defaultProfile = undefined;
+  }
+  await saveConfig(config);
+}
+
+export async function listProfiles(): Promise<{ name: string; profile: Profile; isDefault: boolean }[]> {
+  const config = await loadConfig();
+  return Object.entries(config.profiles).map(([name, profile]) => ({
+    name,
+    profile,
+    isDefault: config.defaultProfile === name,
+  }));
+}
+
+export async function getProfile(name: string): Promise<Profile | undefined> {
+  const config = await loadConfig();
+  return config.profiles[name];
+}

package/src/lib/genie-config.ts

@@ -0,0 +1,164 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import {
+  GenieConfig,
+  GenieConfigSchema,
+  HooksConfig,
+  PresetName,
+} from '../types/genie-config.js';
+
+const GENIE_DIR = join(homedir(), '.genie');
+const GENIE_CONFIG_FILE = join(GENIE_DIR, 'config.json');
+
+/**
+ * Get the path to the genie config directory
+ */
+export function getGenieDir(): string {
+  return GENIE_DIR;
+}
+
+/**
+ * Get the path to the genie config file
+ */
+export function getGenieConfigPath(): string {
+  return GENIE_CONFIG_FILE;
+}
+
+/**
+ * Check if genie config exists
+ */
+export function genieConfigExists(): boolean {
+  return existsSync(GENIE_CONFIG_FILE);
+}
+
+/**
+ * Ensure the genie config directory exists
+ */
+export function ensureGenieDir(): void {
+  if (!existsSync(GENIE_DIR)) {
+    mkdirSync(GENIE_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load genie config, returning defaults if not found
+ */
+export async function loadGenieConfig(): Promise<GenieConfig> {
+  if (!existsSync(GENIE_CONFIG_FILE)) {
+    // Return default config
+    return GenieConfigSchema.parse({});
+  }
+
+  try {
+    const content = readFileSync(GENIE_CONFIG_FILE, 'utf-8');
+    const data = JSON.parse(content);
+    return GenieConfigSchema.parse(data);
+  } catch (error: any) {
+    // If config is invalid, return defaults
+    console.warn(`Warning: Invalid genie config, using defaults: ${error.message}`);
+    return GenieConfigSchema.parse({});
+  }
+}
+
+/**
+ * Save genie config to disk
+ */
+export async function saveGenieConfig(config: GenieConfig): Promise<void> {
+  ensureGenieDir();
+
+  try {
+    const validated = GenieConfigSchema.parse(config);
+    const content = JSON.stringify(validated, null, 2);
+    writeFileSync(GENIE_CONFIG_FILE, content, 'utf-8');
+  } catch (error: any) {
+    throw new Error(`Failed to save genie config: ${error.message}`);
+  }
+}
+
+/**
+ * Get the default genie config
+ */
+export function getDefaultGenieConfig(): GenieConfig {
+  return GenieConfigSchema.parse({});
+}
+
+/**
+ * Check if a hook preset is enabled
+ */
+export function isPresetEnabled(config: GenieConfig, preset: PresetName): boolean {
+  return config.hooks.enabled.includes(preset);
+}
+
+/**
+ * Enable a hook preset
+ */
+export async function enablePreset(preset: PresetName): Promise<void> {
+  const config = await loadGenieConfig();
+  if (!config.hooks.enabled.includes(preset)) {
+    config.hooks.enabled.push(preset);
+    await saveGenieConfig(config);
+  }
+}
+
+/**
+ * Disable a hook preset
+ */
+export async function disablePreset(preset: PresetName): Promise<void> {
+  const config = await loadGenieConfig();
+  config.hooks.enabled = config.hooks.enabled.filter((p) => p !== preset);
+  await saveGenieConfig(config);
+}
+
+/**
+ * Get enabled presets
+ */
+export async function getEnabledPresets(): Promise<PresetName[]> {
+  const config = await loadGenieConfig();
+  return config.hooks.enabled;
+}
+
+/**
+ * Set enabled presets (replaces all)
+ */
+export async function setEnabledPresets(presets: PresetName[]): Promise<void> {
+  const config = await loadGenieConfig();
+  config.hooks.enabled = presets;
+  await saveGenieConfig(config);
+}
+
+/**
+ * Update hooks configuration
+ */
+export async function updateHooksConfig(hooks: Partial<HooksConfig>): Promise<void> {
+  const config = await loadGenieConfig();
+  config.hooks = { ...config.hooks, ...hooks };
+  await saveGenieConfig(config);
+}
+
+/**
+ * Expand ~ to home directory in a path
+ */
+export function expandPath(path: string): string {
+  if (path.startsWith('~/')) {
+    return join(homedir(), path.slice(2));
+  }
+  if (path === '~') {
+    return homedir();
+  }
+  return path;
+}
+
+/**
+ * Contract home directory to ~ in a path (for display)
+ */
+export function contractPath(path: string): string {
+  const home = homedir();
+  if (path.startsWith(home + '/')) {
+    return '~' + path.slice(home.length);
+  }
+  if (path === home) {
+    return '~';
+  }
+  return path;
+}