gemkit-cli 0.2.2 → 0.3.0

package/dist/domains/github/releases.js

@@ -0,0 +1,68 @@
+/**
+ * GitHub releases API - Public repos only, no auth
+ */
+import { loadConfig } from '../config/manager.js';
+import { getCache, setCache } from '../cache/manager.js';
+import { GitHubError } from '../../utils/errors.js';
+const CACHE_KEY = 'github-releases';
+const CACHE_TTL = 300; // 5 minutes
+/**
+ * Fetch releases from GitHub
+ */
+export async function fetchReleases(limit = 10) {
+    // Check cache first
+    const cached = getCache(CACHE_KEY);
+    if (cached) {
+        return cached.slice(0, limit);
+    }
+    const config = loadConfig();
+    const { repo, apiUrl } = config.github;
+    const url = `${apiUrl}/repos/${repo}/releases?per_page=${limit}`;
+    try {
+        const response = await fetch(url, {
+            headers: {
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'gemkit-cli',
+            },
+        });
+        if (!response.ok) {
+            throw new GitHubError(`Failed to fetch releases: ${response.status}`);
+        }
+        const data = await response.json();
+        const releases = data.map(r => ({
+            version: r.tag_name.replace(/^v/, ''),
+            tag: r.tag_name,
+            publishedAt: r.published_at,
+            prerelease: r.prerelease,
+            assets: r.assets.map(a => ({
+                name: a.name,
+                url: a.url,
+                size: a.size,
+                downloadUrl: a.browser_download_url,
+            })),
+        }));
+        // Cache results
+        setCache(CACHE_KEY, releases, CACHE_TTL);
+        return releases;
+    }
+    catch (error) {
+        if (error instanceof GitHubError) {
+            throw error;
+        }
+        throw new GitHubError(`Failed to fetch releases: ${error}`);
+    }
+}
+/**
+ * Get latest release
+ */
+export async function getLatestRelease() {
+    const releases = await fetchReleases(1);
+    return releases.length > 0 ? releases[0] : null;
+}
+/**
+ * Get release by version
+ */
+export async function getReleaseByVersion(version) {
+    const releases = await fetchReleases(50);
+    return releases.find(r => r.version === version || r.tag === version) || null;
+}

package/dist/domains/installation/conflict.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Conflict detection for file updates
+ */
+export interface ConflictInfo {
+    path: string;
+    type: 'modified' | 'deleted' | 'new';
+    localHash?: string;
+    originalHash?: string;
+}
+/**
+ * Detect conflicts between local changes and update
+ */
+export declare function detectConflicts(projectDir?: string): ConflictInfo[];

package/dist/domains/installation/conflict.js

@@ -0,0 +1,38 @@
+/**
+ * Conflict detection for file updates
+ */
+import { existsSync } from 'fs';
+import { hashFile } from '../../services/hash.js';
+import { loadMetadata } from './metadata.js';
+/**
+ * Detect conflicts between local changes and update
+ */
+export function detectConflicts(projectDir) {
+    const conflicts = [];
+    const metadata = loadMetadata(projectDir);
+    if (!metadata) {
+        return conflicts;
+    }
+    // Check customized files
+    for (const custom of metadata.customizedFiles) {
+        if (!existsSync(custom.path)) {
+            conflicts.push({
+                path: custom.path,
+                type: 'deleted',
+                originalHash: custom.hash,
+            });
+        }
+        else {
+            const currentHash = hashFile(custom.path);
+            if (currentHash !== custom.hash) {
+                conflicts.push({
+                    path: custom.path,
+                    type: 'modified',
+                    localHash: currentHash || undefined,
+                    originalHash: custom.hash,
+                });
+            }
+        }
+    }
+    return conflicts;
+}

package/dist/domains/installation/file-sync.d.ts

@@ -0,0 +1,16 @@
+/**
+ * File synchronization for installation/update
+ */
+export interface SyncResult {
+    added: string[];
+    updated: string[];
+    skipped: string[];
+    errors: string[];
+}
+/**
+ * Sync files from source to destination
+ */
+export declare function syncFiles(sourceDir: string, destDir: string, options?: {
+    force?: boolean;
+    excludePatterns?: string[];
+}): SyncResult;

package/dist/domains/installation/file-sync.js

@@ -0,0 +1,77 @@
+/**
+ * File synchronization for installation/update
+ */
+import { existsSync, mkdirSync, readdirSync, copyFileSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { hashFile } from '../../services/hash.js';
+/**
+ * Sync files from source to destination
+ */
+export function syncFiles(sourceDir, destDir, options = {}) {
+    const result = {
+        added: [],
+        updated: [],
+        skipped: [],
+        errors: [],
+    };
+    if (!existsSync(sourceDir)) {
+        result.errors.push(`Source directory not found: ${sourceDir}`);
+        return result;
+    }
+    const files = getAllFiles(sourceDir);
+    for (const file of files) {
+        const relativePath = relative(sourceDir, file);
+        const destPath = join(destDir, relativePath);
+        // Check exclude patterns
+        if (options.excludePatterns?.some(p => relativePath.includes(p))) {
+            result.skipped.push(relativePath);
+            continue;
+        }
+        try {
+            // Ensure destination directory exists
+            const destDirPath = dirname(destPath);
+            if (!existsSync(destDirPath)) {
+                mkdirSync(destDirPath, { recursive: true });
+            }
+            if (!existsSync(destPath)) {
+                // New file
+                copyFileSync(file, destPath);
+                result.added.push(relativePath);
+            }
+            else if (options.force) {
+                // Force update
+                copyFileSync(file, destPath);
+                result.updated.push(relativePath);
+            }
+            else {
+                // Check if file changed
+                const sourceHash = hashFile(file);
+                const destHash = hashFile(destPath);
+                if (sourceHash !== destHash) {
+                    result.skipped.push(relativePath);
+                }
+            }
+        }
+        catch (error) {
+            result.errors.push(`Failed to sync ${relativePath}: ${error}`);
+        }
+    }
+    return result;
+}
+/**
+ * Get all files in directory recursively
+ */
+function getAllFiles(dir) {
+    const files = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...getAllFiles(fullPath));
+        }
+        else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}

package/dist/domains/installation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './metadata.js';
+export * from './file-sync.js';
+export * from './conflict.js';

package/dist/domains/installation/index.js

@@ -0,0 +1,3 @@
+export * from './metadata.js';
+export * from './file-sync.js';
+export * from './conflict.js';

package/dist/domains/installation/metadata.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Installation metadata management
+ */
+import type { GemKitMetadata } from '../../types/index.js';
+/**
+ * Load installation metadata
+ */
+export declare function loadMetadata(projectDir?: string): GemKitMetadata | null;
+/**
+ * Save installation metadata
+ */
+export declare function saveMetadata(metadata: GemKitMetadata, projectDir?: string): void;
+/**
+ * Create initial metadata
+ */
+export declare function createMetadata(version: string, scope: 'local' | 'global', installedFiles: string[]): GemKitMetadata;
+/**
+ * Check if GemKit is installed
+ */
+export declare function isInstalled(projectDir?: string): boolean;

package/dist/domains/installation/metadata.js

@@ -0,0 +1,52 @@
+/**
+ * Installation metadata management
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { getLocalMetadataPath } from '../../utils/paths.js';
+/**
+ * Load installation metadata
+ */
+export function loadMetadata(projectDir) {
+    const metadataPath = getLocalMetadataPath(projectDir);
+    if (!existsSync(metadataPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(metadataPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save installation metadata
+ */
+export function saveMetadata(metadata, projectDir) {
+    const metadataPath = getLocalMetadataPath(projectDir);
+    const dir = dirname(metadataPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+}
+/**
+ * Create initial metadata
+ */
+export function createMetadata(version, scope, installedFiles) {
+    return {
+        name: 'gemkit',
+        version,
+        installedAt: new Date().toISOString(),
+        scope,
+        installedFiles,
+        customizedFiles: [],
+    };
+}
+/**
+ * Check if GemKit is installed
+ */
+export function isInstalled(projectDir) {
+    return loadMetadata(projectDir) !== null;
+}

package/dist/domains/plan/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './resolver.js';

package/dist/domains/plan/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './resolver.js';

package/dist/domains/plan/resolver.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Plan resolver utilities
+ * Replaces: gk-set-active-plan.cjs (setActivePlan function)
+ */
+import { Plan } from './types.js';
+/**
+ * List all plans in project
+ */
+export declare function listPlans(projectDir?: string): Plan[];
+/**
+ * Create a new plan
+ */
+export declare function createPlan(name: string, projectDir?: string): Plan;
+/**
+ * Set active plan in session file AND .env
+ * Matches gk-set-active-plan.cjs behavior:
+ * 1. Updates session.activePlan in ~/.gemkit/projects/{projectDir}/gk-session-{gkSessionId}.json
+ * 2. Updates ACTIVE_PLAN in .gemini/.env
+ */
+export declare function setActivePlan(name: string, projectDir?: string): boolean;
+/**
+ * Get plan info
+ */
+export declare function getPlanInfo(name: string, projectDir?: string): Plan | null;

package/dist/domains/plan/resolver.js

@@ -0,0 +1,164 @@
+/**
+ * Plan resolver utilities
+ * Replaces: gk-set-active-plan.cjs (setActivePlan function)
+ */
+import { existsSync, readdirSync, mkdirSync, writeFileSync, statSync } from 'fs';
+import { join } from 'path';
+import { getPlansDir, getLocalEnvPath } from '../../utils/paths.js';
+import { getActivePlan, getActiveGkSessionId, getProjectDir, readEnv } from '../session/env.js';
+import { getSession } from '../session/manager.js';
+import { setActivePlan as sessionSetActivePlan } from '../session/writer.js';
+/**
+ * List all plans in project
+ */
+export function listPlans(projectDir) {
+    const plansDir = getPlansDir(projectDir);
+    if (!existsSync(plansDir)) {
+        return [];
+    }
+    const activePlan = getActivePlan();
+    const dirs = readdirSync(plansDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+    return dirs.map(name => {
+        const path = join(plansDir, name);
+        const planFile = join(path, 'plan.md');
+        let createdAt = '';
+        // Try to get creation date from plan.md or folder name
+        if (existsSync(planFile)) {
+            const stat = statSync(planFile);
+            createdAt = stat.birthtime.toISOString();
+        }
+        return {
+            name,
+            path,
+            createdAt,
+            isActive: name === activePlan,
+        };
+    });
+}
+/**
+ * Create a new plan
+ */
+export function createPlan(name, projectDir) {
+    const plansDir = getPlansDir(projectDir);
+    const planPath = join(plansDir, name);
+    if (!existsSync(plansDir)) {
+        mkdirSync(plansDir, { recursive: true });
+    }
+    if (existsSync(planPath)) {
+        throw new Error(`Plan already exists: ${name}`);
+    }
+    // Create plan structure
+    mkdirSync(planPath, { recursive: true });
+    mkdirSync(join(planPath, 'research'), { recursive: true });
+    mkdirSync(join(planPath, 'artifacts'), { recursive: true });
+    // Create plan.md template
+    const template = `# ${name}
+
+## Overview
+
+[Describe the plan objectives here]
+
+## Tasks
+
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+
+## Notes
+
+`;
+    writeFileSync(join(planPath, 'plan.md'), template);
+    return {
+        name,
+        path: planPath,
+        createdAt: new Date().toISOString(),
+        isActive: false,
+    };
+}
+/**
+ * Set active plan in session file AND .env
+ * Matches gk-set-active-plan.cjs behavior:
+ * 1. Updates session.activePlan in ~/.gemkit/projects/{projectDir}/gk-session-{gkSessionId}.json
+ * 2. Updates ACTIVE_PLAN in .gemini/.env
+ */
+export function setActivePlan(name, projectDir) {
+    // Get active session ID and project dir from .env
+    const gkSessionId = getActiveGkSessionId();
+    if (!gkSessionId) {
+        // No active session - just update env directly
+        const envPath = getLocalEnvPath(projectDir);
+        const env = readEnv();
+        // Build new env content with ACTIVE_PLAN
+        const content = [
+            '# Auto-generated by gemkit-cli',
+            `# Updated at: ${new Date().toISOString()}`,
+            '',
+            '# GEMKIT IDs',
+            `ACTIVE_GK_SESSION_ID=${env.ACTIVE_GK_SESSION_ID || ''}`,
+            `GK_PROJECT_HASH=${env.GK_PROJECT_HASH || ''}`,
+            `PROJECT_DIR=${env.PROJECT_DIR || ''}`,
+            '',
+            '# GEMINI IDs (mapped)',
+            `ACTIVE_GEMINI_SESSION_ID=${env.ACTIVE_GEMINI_SESSION_ID || ''}`,
+            `GEMINI_PROJECT_HASH=${env.GEMINI_PROJECT_HASH || ''}`,
+            '',
+            '# PLAN INFO',
+            `ACTIVE_PLAN=${name}`,
+            `SUGGESTED_PLAN=${env.SUGGESTED_PLAN || ''}`,
+            `PLAN_DATE_FORMAT=${env.PLAN_DATE_FORMAT || ''}`,
+            ''
+        ].join('\n');
+        writeFileSync(envPath, content);
+        return true;
+    }
+    const projDir = getProjectDir(projectDir);
+    // Verify session exists
+    const session = getSession(projDir, gkSessionId);
+    if (!session) {
+        // Session not found - just update env
+        const envPath = getLocalEnvPath(projectDir);
+        const env = readEnv();
+        const content = [
+            '# Auto-generated by gemkit-cli',
+            `# Updated at: ${new Date().toISOString()}`,
+            '',
+            '# GEMKIT IDs',
+            `ACTIVE_GK_SESSION_ID=${env.ACTIVE_GK_SESSION_ID || ''}`,
+            `GK_PROJECT_HASH=${env.GK_PROJECT_HASH || ''}`,
+            `PROJECT_DIR=${env.PROJECT_DIR || ''}`,
+            '',
+            '# GEMINI IDs (mapped)',
+            `ACTIVE_GEMINI_SESSION_ID=${env.ACTIVE_GEMINI_SESSION_ID || ''}`,
+            `GEMINI_PROJECT_HASH=${env.GEMINI_PROJECT_HASH || ''}`,
+            '',
+            '# PLAN INFO',
+            `ACTIVE_PLAN=${name}`,
+            `SUGGESTED_PLAN=${env.SUGGESTED_PLAN || ''}`,
+            `PLAN_DATE_FORMAT=${env.PLAN_DATE_FORMAT || ''}`,
+            ''
+        ].join('\n');
+        writeFileSync(envPath, content);
+        return true;
+    }
+    // Update session file AND env file using session writer
+    return sessionSetActivePlan(projDir, gkSessionId, name);
+}
+/**
+ * Get plan info
+ */
+export function getPlanInfo(name, projectDir) {
+    const plansDir = getPlansDir(projectDir);
+    const planPath = join(plansDir, name);
+    if (!existsSync(planPath)) {
+        return null;
+    }
+    const activePlan = getActivePlan();
+    return {
+        name,
+        path: planPath,
+        createdAt: '',
+        isActive: name === activePlan,
+    };
+}

package/dist/domains/plan/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plan type definitions
+ */
+export interface Plan {
+    name: string;
+    path: string;
+    createdAt: string;
+    isActive: boolean;
+}
+export interface PlanTemplate {
+    name: string;
+    content: string;
+}

package/dist/domains/plan/types.js

@@ -0,0 +1,4 @@
+/**
+ * Plan type definitions
+ */
+export {};

package/dist/domains/session/env.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Environment variable utilities for session management
+ * Aligned with gk-session-manager.cjs readEnv()
+ */
+/**
+ * Environment data structure matching gk-session-manager.cjs
+ */
+export interface GkEnvData {
+    ACTIVE_GK_SESSION_ID: string;
+    GK_PROJECT_HASH: string;
+    PROJECT_DIR: string;
+    ACTIVE_GEMINI_SESSION_ID: string;
+    GEMINI_PROJECT_HASH: string;
+    GEMINI_PARENT_ID: string;
+    ACTIVE_PLAN: string;
+    SUGGESTED_PLAN: string;
+    PLAN_DATE_FORMAT: string;
+}
+/**
+ * Read environment variables from .gemini/.env
+ * Matches gk-session-manager.cjs readEnv()
+ */
+export declare function readEnv(projectPath?: string): GkEnvData;
+/**
+ * Get active GK session ID from .gemini/.env
+ */
+export declare function getActiveGkSessionId(projectPath?: string): string | undefined;
+/**
+ * Get active Gemini session ID from .gemini/.env
+ */
+export declare function getActiveGeminiSessionId(projectPath?: string): string | undefined;
+/**
+ * Get project directory from .gemini/.env or derive from cwd
+ */
+export declare function getProjectDir(projectPath?: string): string;
+/**
+ * Get GK project hash from .gemini/.env
+ */
+export declare function getGkProjectHash(projectPath?: string): string | undefined;
+/**
+ * Get Gemini project hash from .gemini/.env
+ */
+export declare function getGeminiProjectHash(projectPath?: string): string | undefined;
+/**
+ * Get active plan from .gemini/.env
+ */
+export declare function getActivePlan(projectPath?: string): string | undefined;
+/**
+ * Get suggested plan from .gemini/.env
+ */
+export declare function getSuggestedPlan(projectPath?: string): string | undefined;

package/dist/domains/session/env.js

@@ -0,0 +1,118 @@
+/**
+ * Environment variable utilities for session management
+ * Aligned with gk-session-manager.cjs readEnv()
+ */
+import { existsSync, readFileSync } from 'fs';
+import { getLocalEnvPath, sanitizeProjectPath } from '../../utils/paths.js';
+/**
+ * Read environment variables from .gemini/.env
+ * Matches gk-session-manager.cjs readEnv()
+ */
+export function readEnv(projectPath = process.cwd()) {
+    const result = {
+        // GemKit IDs
+        ACTIVE_GK_SESSION_ID: '',
+        GK_PROJECT_HASH: '',
+        PROJECT_DIR: '',
+        // Gemini IDs (mapped)
+        ACTIVE_GEMINI_SESSION_ID: '',
+        GEMINI_PROJECT_HASH: '',
+        GEMINI_PARENT_ID: '',
+        // Plan info
+        ACTIVE_PLAN: '',
+        SUGGESTED_PLAN: '',
+        PLAN_DATE_FORMAT: ''
+    };
+    const envPath = getLocalEnvPath(projectPath);
+    if (!existsSync(envPath)) {
+        return result;
+    }
+    try {
+        const content = readFileSync(envPath, 'utf-8');
+        // GemKit IDs
+        const gkSessionMatch = content.match(/^ACTIVE_GK_SESSION_ID=(.*)$/m);
+        if (gkSessionMatch)
+            result.ACTIVE_GK_SESSION_ID = gkSessionMatch[1].trim();
+        const gkHashMatch = content.match(/^GK_PROJECT_HASH=(.*)$/m);
+        if (gkHashMatch)
+            result.GK_PROJECT_HASH = gkHashMatch[1].trim();
+        const projectDirMatch = content.match(/^PROJECT_DIR=(.*)$/m);
+        if (projectDirMatch)
+            result.PROJECT_DIR = projectDirMatch[1].trim();
+        // Gemini IDs
+        const geminiSessionMatch = content.match(/^ACTIVE_GEMINI_SESSION_ID=(.*)$/m);
+        if (geminiSessionMatch)
+            result.ACTIVE_GEMINI_SESSION_ID = geminiSessionMatch[1].trim();
+        const geminiHashMatch = content.match(/^GEMINI_PROJECT_HASH=(.*)$/m);
+        if (geminiHashMatch)
+            result.GEMINI_PROJECT_HASH = geminiHashMatch[1].trim();
+        const geminiParentMatch = content.match(/^GEMINI_PARENT_ID=(.*)$/m);
+        if (geminiParentMatch)
+            result.GEMINI_PARENT_ID = geminiParentMatch[1].trim();
+        // Plan info
+        const activePlanMatch = content.match(/^ACTIVE_PLAN=(.*)$/m);
+        if (activePlanMatch)
+            result.ACTIVE_PLAN = activePlanMatch[1].trim();
+        const suggestedPlanMatch = content.match(/^SUGGESTED_PLAN=(.*)$/m);
+        if (suggestedPlanMatch)
+            result.SUGGESTED_PLAN = suggestedPlanMatch[1].trim();
+        const dateFormatMatch = content.match(/^PLAN_DATE_FORMAT=(.*)$/m);
+        if (dateFormatMatch)
+            result.PLAN_DATE_FORMAT = dateFormatMatch[1].trim();
+    }
+    catch (e) {
+        // Return empty values on error
+    }
+    return result;
+}
+/**
+ * Get active GK session ID from .gemini/.env
+ */
+export function getActiveGkSessionId(projectPath = process.cwd()) {
+    const env = readEnv(projectPath);
+    return env.ACTIVE_GK_SESSION_ID || undefined;
+}
+/**
+ * Get active Gemini session ID from .gemini/.env
+ */
+export function getActiveGeminiSessionId(projectPath = process.cwd()) {
+    const env = readEnv(projectPath);
+    return env.ACTIVE_GEMINI_SESSION_ID || undefined;
+}
+/**
+ * Get project directory from .gemini/.env or derive from cwd
+ */
+export function getProjectDir(projectPath = process.cwd()) {
+    const env = readEnv(projectPath);
+    if (env.PROJECT_DIR)
+        return env.PROJECT_DIR;
+    return sanitizeProjectPath(projectPath);
+}
+/**
+ * Get GK project hash from .gemini/.env
+ */
+export function getGkProjectHash(projectPath = process.cwd()) {
+    const env = readEnv(projectPath);
+    return env.GK_PROJECT_HASH || undefined;
+}
+/**
+ * Get Gemini project hash from .gemini/.env
+ */
+export function getGeminiProjectHash(projectPath = process.cwd()) {
+    const env = readEnv(projectPath);
+    return env.GEMINI_PROJECT_HASH || undefined;
+}
+/**
+ * Get active plan from .gemini/.env
+ */
+export function getActivePlan(projectPath = process.cwd()) {
+    const env = readEnv(projectPath);
+    return env.ACTIVE_PLAN || undefined;
+}
+/**
+ * Get suggested plan from .gemini/.env
+ */
+export function getSuggestedPlan(projectPath = process.cwd()) {
+    const env = readEnv(projectPath);
+    return env.SUGGESTED_PLAN || undefined;
+}