gemkit-cli 0.2.2 → 0.3.0

package/dist/types/index.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Core type definitions for GemKit CLI
+ */
+export interface GemKitConfig {
+    defaultScope: 'local' | 'global';
+    github: {
+        repo: string;
+        apiUrl: string;
+    };
+    cache: {
+        enabled: boolean;
+        ttl: number;
+    };
+    installation: {
+        excludePatterns: string[];
+        backupOnUpdate: boolean;
+    };
+    ui: {
+        colors: boolean;
+        spinner: boolean;
+        verbose: boolean;
+    };
+    paths: {
+        plans?: string;
+        agents?: string;
+    };
+    spawn: {
+        defaultModel: string;
+        music: boolean;
+        musicFile?: string;
+    };
+    office?: {
+        enabled: boolean;
+        mode: 'web' | 'terminal' | 'both';
+        port: number;
+        autoOpen: boolean;
+        sounds: boolean;
+        refreshRate: number;
+    };
+    update?: {
+        autoCheck: boolean;
+        checkInterval: number;
+        notifyOnly: boolean;
+    };
+}
+export interface GemKitMetadata {
+    name: string;
+    version: string;
+    installedAt: string;
+    scope: 'local' | 'global';
+    installedFiles: string[];
+    customizedFiles: Array<{
+        path: string;
+        hash: string;
+    }>;
+}
+export interface Release {
+    version: string;
+    tag: string;
+    publishedAt: string;
+    assets: ReleaseAsset[];
+    prerelease: boolean;
+}
+export interface ReleaseAsset {
+    name: string;
+    url: string;
+    size: number;
+    downloadUrl: string;
+}
+export interface GkSession {
+    gkSessionId: string;
+    geminiSessionId?: string;
+    gkProjectHash: string;
+    projectDir: string;
+    status: 'active' | 'completed' | 'failed';
+    startTime: string;
+    endTime?: string;
+    activePlan?: string;
+    agents: GkAgent[];
+}
+export interface GkAgent {
+    gkSessionId: string;
+    geminiSessionId?: string;
+    agentRole: string;
+    model: string;
+    prompt: string;
+    status: 'active' | 'completed' | 'failed';
+    startTime: string;
+    endTime?: string;
+    tokenUsage?: TokenUsage;
+    injected?: {
+        skills?: string[];
+        context?: string[];
+    };
+}
+export interface TokenUsage {
+    input: number;
+    output: number;
+    cached: number;
+    thoughts: number;
+    tool: number;
+    total: number;
+}
+export interface AgentProfile {
+    name: string;
+    description: string;
+    model: string;
+    skills?: string[];
+    content: string;
+    filePath: string;
+}
+export interface SpawnOptions {
+    prompt: string;
+    agent?: string;
+    skills?: string;
+    context?: string;
+    model?: string;
+}
+export interface SpawnResult {
+    success: boolean;
+    output?: string;
+    error?: string;
+    exitCode: number;
+    prompt?: string;
+    tokenUsage?: TokenUsage;
+    agentRole?: string;
+}
+export interface SearchResult {
+    agent: string;
+    skills: string[];
+    score: number;
+    description: string;
+}
+export interface Plan {
+    name: string;
+    path: string;
+    createdAt: string;
+    isActive: boolean;
+}
+export interface Extension {
+    name: string;
+    path: string;
+    skills: string[];
+    tools: ExtensionTool[];
+}
+export interface ExtensionTool {
+    name: string;
+    description: string;
+    command?: string;
+}
+export interface CommandContext {
+    cwd: string;
+    verbose: boolean;
+    json: boolean;
+}

package/dist/types/index.js

@@ -0,0 +1,4 @@
+/**
+ * Core type definitions for GemKit CLI
+ */
+export {};

package/dist/utils/colors.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Brand colors and styling for GemKit CLI
+ * Matches gemkit-cli theme
+ */
+import pc from 'picocolors';
+export declare const brand: {
+    primary: (text: string) => string;
+    secondary: (text: string) => string;
+    accent: (text: string) => string;
+    geminiBlue: (text: string) => string;
+    geminiPurple: (text: string) => string;
+    success: (text: string) => string;
+    error: (text: string) => string;
+    warn: (text: string) => string;
+    info: (text: string) => string;
+    dim: (text: string) => string;
+};
+/**
+ * UI helpers
+ */
+export declare const ui: {
+    line: (width?: number) => string;
+    doubleLine: (width?: number) => string;
+    statusIcon: (status: string) => string;
+    checkIcon: (passed: boolean, optional?: boolean) => string;
+    header: (text: string) => string;
+    section: (title: string, width?: number) => void;
+};
+/**
+ * Prints the GemKit CLI banner.
+ */
+export declare function printBanner(): void;
+export declare const colors: {
+    success: (text: string) => string;
+    error: (text: string) => string;
+    warning: (text: string) => string;
+    info: (text: string) => string;
+    dim: (text: string) => string;
+    primary: (text: string) => string;
+    secondary: (text: string) => string;
+    bold: import("picocolors/types.js").Formatter;
+};
+export { pc };

package/dist/utils/colors.js

@@ -0,0 +1,98 @@
+/**
+ * Brand colors and styling for GemKit CLI
+ * Matches gemkit-cli theme
+ */
+import pc from 'picocolors';
+/**
+ * Converts a hex color string to an ANSI escape sequence for 24-bit truecolor.
+ */
+const hexToAnsi = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return `\x1b[38;2;${r};${g};${b}m`;
+};
+/**
+ * Wraps text in a 24-bit truecolor ANSI escape sequence.
+ */
+const wrap = (hex) => (text) => {
+    if (!pc.isColorSupported)
+        return text;
+    return `${hexToAnsi(hex)}${text}\x1b[39m`;
+};
+export const brand = {
+    // Brand colors
+    primary: wrap('#4f46e5'),
+    secondary: wrap('#9333ea'),
+    accent: wrap('#06b6d4'),
+    geminiBlue: wrap('#1a73e8'),
+    geminiPurple: wrap('#8e24aa'),
+    // Semantic colors
+    success: (text) => pc.green(text),
+    error: (text) => pc.red(text),
+    warn: (text) => pc.yellow(text),
+    info: (text) => pc.cyan(text),
+    dim: (text) => pc.dim(text),
+};
+/**
+ * UI helpers
+ */
+export const ui = {
+    // Horizontal lines
+    line: (width = 60) => '─'.repeat(width),
+    doubleLine: (width = 60) => '═'.repeat(width),
+    // Status icons
+    statusIcon: (status) => {
+        switch (status) {
+            case 'active': return brand.success('●');
+            case 'completed': return brand.dim('○');
+            case 'failed': return brand.error('✗');
+            default: return '?';
+        }
+    },
+    // Check icons
+    checkIcon: (passed, optional = false) => {
+        if (passed)
+            return brand.success('✓');
+        return optional ? brand.warn('○') : brand.error('✗');
+    },
+    // Header
+    header: (text) => pc.bold(brand.geminiPurple(text)),
+    // Section with lines
+    section: (title, width = 60) => {
+        console.log();
+        console.log('─'.repeat(width));
+        console.log(pc.bold(brand.geminiPurple(title)));
+        console.log('─'.repeat(width));
+        console.log();
+    },
+};
+/**
+ * Prints the GemKit CLI banner.
+ */
+export function printBanner() {
+    console.log();
+    console.log(pc.bold(brand.geminiPurple('  ┌─────────────────────────────┐')));
+    console.log(pc.bold(brand.geminiPurple('  │')) +
+        '  ' +
+        pc.bold(brand.primary('GK')) +
+        ' ' +
+        pc.white('GemKit CLI MVP') +
+        '       ' +
+        pc.bold(brand.geminiPurple('│')));
+    console.log(pc.bold(brand.geminiPurple('  └─────────────────────────────┘')));
+    console.log();
+}
+// Legacy compatibility - map old colors to new brand
+export const colors = {
+    success: brand.success,
+    error: brand.error,
+    warning: brand.warn,
+    info: brand.info,
+    dim: brand.dim,
+    primary: brand.primary,
+    secondary: brand.secondary,
+    bold: pc.bold,
+};
+// Re-export picocolors
+export { pc };

package/dist/utils/errors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom error classes for GemKit CLI
+ */
+export declare class GemKitError extends Error {
+    code: string;
+    details?: Record<string, unknown> | undefined;
+    constructor(message: string, code?: string, details?: Record<string, unknown> | undefined);
+}
+export declare class ConfigError extends GemKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+export declare class InstallationError extends GemKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+export declare class SessionError extends GemKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+export declare class AgentError extends GemKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+export declare class GitHubError extends GemKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+export declare function formatErrorForDisplay(error: unknown): string;

package/dist/utils/errors.js

@@ -0,0 +1,56 @@
+/**
+ * Custom error classes for GemKit CLI
+ */
+export class GemKitError extends Error {
+    code;
+    details;
+    constructor(message, code = 'GEMKIT_ERROR', details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'GemKitError';
+    }
+}
+export class ConfigError extends GemKitError {
+    constructor(message, details) {
+        super(message, 'CONFIG_ERROR', details);
+        this.name = 'ConfigError';
+    }
+}
+export class InstallationError extends GemKitError {
+    constructor(message, details) {
+        super(message, 'INSTALLATION_ERROR', details);
+        this.name = 'InstallationError';
+    }
+}
+export class SessionError extends GemKitError {
+    constructor(message, details) {
+        super(message, 'SESSION_ERROR', details);
+        this.name = 'SessionError';
+    }
+}
+export class AgentError extends GemKitError {
+    constructor(message, details) {
+        super(message, 'AGENT_ERROR', details);
+        this.name = 'AgentError';
+    }
+}
+export class GitHubError extends GemKitError {
+    constructor(message, details) {
+        super(message, 'GITHUB_ERROR', details);
+        this.name = 'GitHubError';
+    }
+}
+export function formatErrorForDisplay(error) {
+    if (error instanceof GemKitError) {
+        let message = `[${error.code}] ${error.message}`;
+        if (error.details) {
+            message += `\nDetails: ${JSON.stringify(error.details, null, 2)}`;
+        }
+        return message;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Path constants and utilities for GemKit CLI
+ * Aligned with gk-session-manager.cjs
+ */
+export declare const GEMKIT_HOME: string;
+export declare const GEMKIT_PROJECTS_DIR: string;
+export declare const GEMINI_HOME: string;
+export declare const GEMKIT_CONFIG_DIR: string;
+export declare const GEMKIT_CACHE_DIR: string;
+export declare const GEMKIT_TMP_DIR: string;
+export declare const LOCAL_GEMINI_DIR = ".gemini";
+export declare const LOCAL_AGENT_DIR = ".agent";
+export declare const LOCAL_PLANS_DIR = "plans";
+export declare const CONFIG_FILE = ".gk.json";
+export declare const METADATA_FILE = "metadata.json";
+export declare const ENV_FILE = ".env";
+export declare function getLocalGeminiDir(projectDir?: string): string;
+export declare function getLocalConfigPath(projectDir?: string): string;
+export declare function getLocalMetadataPath(projectDir?: string): string;
+export declare function getLocalEnvPath(projectDir?: string): string;
+export declare function getAgentsDir(projectDir?: string): string;
+export declare function getExtensionsDir(projectDir?: string): string;
+export declare function getPlansDir(projectDir?: string): string;
+/**
+ * Sanitize path to create safe directory name
+ * Matches gk-session-manager.cjs sanitizeProjectPath()
+ */
+export declare function sanitizeProjectPath(projectPath: string): string;
+/**
+ * Get project data directory
+ * Matches gk-session-manager.cjs getProjectDataDir()
+ * Storage: ~/.gemkit/projects/{projectDir}/
+ */
+export declare function getProjectDataDir(projectDir: string): string;
+/**
+ * Get session file path
+ * Matches gk-session-manager.cjs getSessionPath()
+ */
+export declare function getSessionPath(projectDir: string, gkSessionId: string): string;
+/**
+ * Get project file path
+ * Matches gk-session-manager.cjs getProjectPath()
+ */
+export declare function getProjectPath(projectDir: string, gkProjectHash: string): string;
+export declare function getTempDir(projectHash?: string): string;
+export declare function getCacheDir(): string;

package/dist/utils/paths.js

@@ -0,0 +1,89 @@
+/**
+ * Path constants and utilities for GemKit CLI
+ * Aligned with gk-session-manager.cjs
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+// Global paths - aligned with gk-session-manager.cjs
+export const GEMKIT_HOME = join(homedir(), '.gemkit');
+export const GEMKIT_PROJECTS_DIR = join(GEMKIT_HOME, 'projects');
+// Legacy paths (for backwards compatibility)
+export const GEMINI_HOME = join(homedir(), '.gemini');
+export const GEMKIT_CONFIG_DIR = join(GEMINI_HOME, 'config');
+export const GEMKIT_CACHE_DIR = join(GEMINI_HOME, 'cache');
+export const GEMKIT_TMP_DIR = join(GEMINI_HOME, 'tmp');
+// Local paths (relative to project)
+export const LOCAL_GEMINI_DIR = '.gemini';
+export const LOCAL_AGENT_DIR = '.agent';
+export const LOCAL_PLANS_DIR = 'plans';
+// File names
+export const CONFIG_FILE = '.gk.json';
+export const METADATA_FILE = 'metadata.json';
+export const ENV_FILE = '.env';
+// Get local paths
+export function getLocalGeminiDir(projectDir = process.cwd()) {
+    return join(projectDir, LOCAL_GEMINI_DIR);
+}
+export function getLocalConfigPath(projectDir = process.cwd()) {
+    return join(projectDir, LOCAL_GEMINI_DIR, CONFIG_FILE);
+}
+export function getLocalMetadataPath(projectDir = process.cwd()) {
+    return join(projectDir, LOCAL_GEMINI_DIR, METADATA_FILE);
+}
+export function getLocalEnvPath(projectDir = process.cwd()) {
+    return join(projectDir, LOCAL_GEMINI_DIR, ENV_FILE);
+}
+export function getAgentsDir(projectDir = process.cwd()) {
+    return join(projectDir, LOCAL_GEMINI_DIR, 'agents');
+}
+export function getExtensionsDir(projectDir = process.cwd()) {
+    return join(projectDir, LOCAL_GEMINI_DIR, 'extensions');
+}
+export function getPlansDir(projectDir = process.cwd()) {
+    return join(projectDir, LOCAL_PLANS_DIR);
+}
+/**
+ * Sanitize path to create safe directory name
+ * Matches gk-session-manager.cjs sanitizeProjectPath()
+ */
+export function sanitizeProjectPath(projectPath) {
+    if (!projectPath)
+        return '';
+    return projectPath
+        .replace(/^[A-Za-z]:/, m => m.replace(':', '')) // C: -> C
+        .replace(/[\\/]+/g, '-') // path separators to hyphens
+        .replace(/[^a-zA-Z0-9-]/g, '-') // other special chars to hyphens
+        .replace(/-+/g, '-') // collapse multiple hyphens
+        .replace(/^-|-$/g, ''); // trim leading/trailing hyphens
+}
+/**
+ * Get project data directory
+ * Matches gk-session-manager.cjs getProjectDataDir()
+ * Storage: ~/.gemkit/projects/{projectDir}/
+ */
+export function getProjectDataDir(projectDir) {
+    return join(GEMKIT_PROJECTS_DIR, projectDir);
+}
+/**
+ * Get session file path
+ * Matches gk-session-manager.cjs getSessionPath()
+ */
+export function getSessionPath(projectDir, gkSessionId) {
+    return join(getProjectDataDir(projectDir), `gk-session-${gkSessionId}.json`);
+}
+/**
+ * Get project file path
+ * Matches gk-session-manager.cjs getProjectPath()
+ */
+export function getProjectPath(projectDir, gkProjectHash) {
+    return join(getProjectDataDir(projectDir), `gk-project-${gkProjectHash}.json`);
+}
+export function getTempDir(projectHash) {
+    if (projectHash) {
+        return join(GEMKIT_TMP_DIR, projectHash);
+    }
+    return GEMKIT_TMP_DIR;
+}
+export function getCacheDir() {
+    return GEMKIT_CACHE_DIR;
+}

package/dist/utils/platform.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Platform detection utilities
+ */
+export type Platform = 'win32' | 'darwin' | 'linux' | 'unknown';
+export declare function getPlatform(): Platform;
+export declare function isWindows(): boolean;
+export declare function isMacOS(): boolean;
+export declare function isLinux(): boolean;
+export declare function getShell(): string;
+export declare function getHomeDir(): string;
+export declare function getPathSeparator(): string;

package/dist/utils/platform.js

@@ -0,0 +1,31 @@
+/**
+ * Platform detection utilities
+ */
+export function getPlatform() {
+    const platform = process.platform;
+    if (platform === 'win32' || platform === 'darwin' || platform === 'linux') {
+        return platform;
+    }
+    return 'unknown';
+}
+export function isWindows() {
+    return process.platform === 'win32';
+}
+export function isMacOS() {
+    return process.platform === 'darwin';
+}
+export function isLinux() {
+    return process.platform === 'linux';
+}
+export function getShell() {
+    if (isWindows()) {
+        return process.env.COMSPEC || 'cmd.exe';
+    }
+    return process.env.SHELL || '/bin/sh';
+}
+export function getHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || '';
+}
+export function getPathSeparator() {
+    return isWindows() ? ';' : ':';
+}

package/package.json

@@ -1,54 +1,55 @@
-{
-  "name": "gemkit-cli",
-  "version": "0.2.2",
-  "description": "CLI for working with Gemini AI agents, plans, and sessions",
-  "type": "module",
-  "author": "Richard Ng <the.richardng.ai@gmail.com>",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/therichardngai-code/gemkit-cli.git"
-  },
-  "homepage": "https://gemkit.cc",
-  "bugs": {
-    "url": "https://github.com/therichardngai-code/gemkit-cli/issues"
-  },
-  "keywords": [
-    "cli",
-    "gemkit",
-    "gemini",
-    "ai"
-  ],
-  "main": "dist/index.js",
-  "bin": {
-    "gk": "dist/index.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --format=esm --minify --outfile=dist/index.js --external:ws",
-    "build:dev": "tsc",
-    "typecheck": "tsc --noEmit",
-    "dev": "tsc --watch",
-    "start": "node dist/index.js"
-  },
-  "dependencies": {
-    "cac": "^6.7.14",
-    "dotenv": "^16.3.1",
-    "ora": "^8.0.1",
-    "picocolors": "^1.1.1",
-    "tar": "^7.5.2",
-    "ws": "^8.19.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.10.0",
-    "@types/tar": "^6.1.13",
-    "@types/ws": "^8.18.1",
-    "esbuild": "^0.27.2",
-    "typescript": "^5.3.0"
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "gemkit-cli",
+  "version": "0.3.0",
+  "description": "CLI for working with Gemini AI agents, plans, and sessions",
+  "type": "module",
+  "author": "Richard Ng <the.richardng.ai@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/therichardngai-code/gemkit-cli.git"
+  },
+  "homepage": "https://gemkit.cc",
+  "bugs": {
+    "url": "https://github.com/therichardngai-code/gemkit-cli/issues"
+  },
+  "keywords": [
+    "cli",
+    "gemkit",
+    "gemini",
+    "ai"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "gk": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --format=esm --minify --outfile=dist/index.js --external:ws --external:node-pty",
+    "build:dev": "tsc",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "cac": "^6.7.14",
+    "dotenv": "^16.3.1",
+    "node-pty": "^1.1.0",
+    "ora": "^8.0.1",
+    "picocolors": "^1.1.1",
+    "tar": "^7.5.2",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/tar": "^6.1.13",
+    "@types/ws": "^8.18.1",
+    "esbuild": "^0.27.2",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}