keystone-cli 0.1.0

package/src/ui/dashboard.tsx

@@ -0,0 +1,165 @@
+import { Box, Newline, Text, render, useInput } from 'ink';
+import React, { useState, useEffect, useCallback } from 'react';
+import { WorkflowDb } from '../db/workflow-db.ts';
+
+interface Run {
+  id: string;
+  workflow_name: string;
+  status: string;
+  started_at: string;
+}
+
+const Dashboard = () => {
+  const [runs, setRuns] = useState<Run[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  const fetchData = useCallback(() => {
+    const db = new WorkflowDb();
+    try {
+      const recentRuns = db.listRuns(10);
+      setRuns(recentRuns);
+    } catch (error) {
+      console.error('Failed to fetch runs:', error);
+    } finally {
+      setLoading(false);
+      db.close();
+    }
+  }, []);
+
+  useEffect(() => {
+    fetchData();
+    const interval = setInterval(fetchData, 2000);
+    return () => clearInterval(interval);
+  }, [fetchData]);
+
+  useInput((input) => {
+    if (input === 'r') {
+      fetchData();
+    }
+  });
+
+  if (loading) {
+    return (
+      <Box>
+        <Text color="cyan">Loading Keystone Dashboard...</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Box marginBottom={1}>
+        <Text bold color="magenta">
+          🏛️ KEYSTONE DASHBOARD
+        </Text>
+      </Box>
+
+      <Box borderStyle="round" borderColor="gray" flexDirection="column" paddingX={1}>
+        <Box marginBottom={0}>
+          <Box width={12}>
+            <Text bold color="cyan">
+              ID
+            </Text>
+          </Box>
+          <Box width={30}>
+            <Text bold color="cyan">
+              WORKFLOW
+            </Text>
+          </Box>
+          <Box width={15}>
+            <Text bold color="cyan">
+              STATUS
+            </Text>
+          </Box>
+          <Box>
+            <Text bold color="cyan">
+              STARTED
+            </Text>
+          </Box>
+        </Box>
+
+        <Box marginBottom={1}>
+          <Text color="gray">{'─'.repeat(80)}</Text>
+        </Box>
+
+        {runs.length === 0 ? (
+          <Text italic color="gray">
+            No workflow runs found.
+          </Text>
+        ) : (
+          runs.map((run) => (
+            <Box key={run.id} marginBottom={0}>
+              <Box width={12}>
+                <Text color="gray">{run.id.substring(0, 8)}</Text>
+              </Box>
+              <Box width={30}>
+                <Text>{run.workflow_name}</Text>
+              </Box>
+              <Box width={15}>
+                <Text color={getStatusColor(run.status)}>
+                  {getStatusIcon(run.status)} {run.status.toUpperCase()}
+                </Text>
+              </Box>
+              <Box>
+                <Text color="gray">{new Date(run.started_at).toLocaleString()}</Text>
+              </Box>
+            </Box>
+          ))
+        )}
+      </Box>
+
+      <Box marginTop={1} paddingX={1}>
+        <Text color="gray">
+          <Text bold color="white">
+            {' '}
+            r{' '}
+          </Text>{' '}
+          refresh •
+          <Text bold color="white">
+            {' '}
+            Ctrl+C{' '}
+          </Text>{' '}
+          exit •<Text italic> Auto-refreshing every 2s</Text>
+        </Text>
+      </Box>
+    </Box>
+  );
+};
+
+const getStatusColor = (status: string) => {
+  switch (status.toLowerCase()) {
+    case 'completed':
+      return 'green';
+    case 'failed':
+      return 'red';
+    case 'running':
+      return 'yellow';
+    case 'paused':
+      return 'blue';
+    case 'pending':
+      return 'gray';
+    default:
+      return 'white';
+  }
+};
+
+const getStatusIcon = (status: string) => {
+  switch (status.toLowerCase()) {
+    case 'completed':
+      return '✅';
+    case 'failed':
+      return '❌';
+    case 'running':
+      return '⏳';
+    case 'paused':
+      return '⏸️';
+    case 'pending':
+      return '⚪';
+    default:
+      return '🔹';
+  }
+};
+
+export const startDashboard = () => {
+  render(<Dashboard />);
+};

package/src/utils/auth-manager.test.ts

@@ -0,0 +1,152 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, mock, spyOn } from 'bun:test';
+import * as fs from 'node:fs';
+import { join } from 'node:path';
+import { AuthManager } from './auth-manager.ts';
+
+describe('AuthManager', () => {
+  const originalFetch = global.fetch;
+  const TEMP_AUTH_DIR = join(
+    process.cwd(),
+    `temp-auth-test-${Math.random().toString(36).substring(7)}`
+  );
+  const TEMP_AUTH_FILE = join(TEMP_AUTH_DIR, 'auth.json');
+
+  beforeAll(() => {
+    if (!fs.existsSync(TEMP_AUTH_DIR)) {
+      fs.mkdirSync(TEMP_AUTH_DIR, { recursive: true });
+    }
+  });
+
+  afterAll(() => {
+    global.fetch = originalFetch;
+    if (fs.existsSync(TEMP_AUTH_DIR)) {
+      fs.rmSync(TEMP_AUTH_DIR, { recursive: true, force: true });
+    }
+  });
+
+  beforeEach(() => {
+    if (fs.existsSync(TEMP_AUTH_FILE)) {
+      try {
+        fs.rmSync(TEMP_AUTH_FILE);
+      } catch (e) {}
+    }
+    global.fetch = originalFetch;
+    // Set environment variable for EACH test to be safe
+    process.env.KEYSTONE_AUTH_PATH = TEMP_AUTH_FILE;
+  });
+
+  describe('load()', () => {
+    it('should return empty object if auth file does not exist', () => {
+      const data = AuthManager.load();
+      expect(data).toEqual({});
+    });
+
+    it('should load and parse auth data if file exists', () => {
+      fs.writeFileSync(TEMP_AUTH_FILE, JSON.stringify({ github_token: 'test-token' }));
+
+      const data = AuthManager.load();
+      expect(data).toEqual({ github_token: 'test-token' });
+    });
+
+    it('should return empty object if JSON parsing fails', () => {
+      fs.writeFileSync(TEMP_AUTH_FILE, 'invalid-json');
+
+      const data = AuthManager.load();
+      expect(data).toEqual({});
+    });
+  });
+
+  describe('save()', () => {
+    it('should save data merged with current data', () => {
+      fs.writeFileSync(TEMP_AUTH_FILE, JSON.stringify({ github_token: 'old-token' }));
+
+      AuthManager.save({ copilot_token: 'new-copilot-token' });
+
+      const content = fs.readFileSync(TEMP_AUTH_FILE, 'utf8');
+      expect(JSON.parse(content)).toEqual({
+        github_token: 'old-token',
+        copilot_token: 'new-copilot-token',
+      });
+    });
+  });
+
+  describe('getCopilotToken()', () => {
+    it('should return undefined if no github_token', async () => {
+      fs.writeFileSync(TEMP_AUTH_FILE, JSON.stringify({}));
+      const token = await AuthManager.getCopilotToken();
+      expect(token).toBeUndefined();
+    });
+
+    it('should return cached token if valid', async () => {
+      const expires = Math.floor(Date.now() / 1000) + 1000;
+      fs.writeFileSync(
+        TEMP_AUTH_FILE,
+        JSON.stringify({
+          github_token: 'gh-token',
+          copilot_token: 'cached-token',
+          copilot_expires_at: expires,
+        })
+      );
+
+      const token = await AuthManager.getCopilotToken();
+      expect(token).toBe('cached-token');
+    });
+
+    it('should refresh token if expired', async () => {
+      fs.writeFileSync(
+        TEMP_AUTH_FILE,
+        JSON.stringify({
+          github_token: 'gh-token',
+          copilot_token: 'expired-token',
+          copilot_expires_at: Math.floor(Date.now() / 1000) - 1000,
+        })
+      );
+
+      // Mock fetch
+      const mockFetch = mock(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              token: 'new-token',
+              expires_at: Math.floor(Date.now() / 1000) + 3600,
+            }),
+            { status: 200 }
+          )
+        )
+      );
+      // @ts-ignore
+      global.fetch = mockFetch;
+
+      const token = await AuthManager.getCopilotToken();
+      expect(token).toBe('new-token');
+      expect(mockFetch).toHaveBeenCalled();
+    });
+
+    it('should return undefined and log error if refresh fails', async () => {
+      fs.writeFileSync(
+        TEMP_AUTH_FILE,
+        JSON.stringify({
+          github_token: 'gh-token',
+        })
+      );
+
+      // Mock fetch failure
+      // @ts-ignore
+      global.fetch = mock(() =>
+        Promise.resolve(
+          new Response('Unauthorized', {
+            status: 401,
+            statusText: 'Unauthorized',
+          })
+        )
+      );
+
+      const consoleSpy = spyOn(console, 'error').mockImplementation(() => {});
+      const token = await AuthManager.getCopilotToken();
+
+      expect(token).toBeUndefined();
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/src/utils/auth-manager.ts

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export interface AuthData {
+  github_token?: string;
+  copilot_token?: string;
+  copilot_expires_at?: number;
+}
+
+export const COPILOT_HEADERS = {
+  'Editor-Version': 'vscode/1.96.2',
+  'Editor-Plugin-Version': 'copilot-chat/0.23.1',
+  'User-Agent': 'GithubCopilot/1.255.0',
+};
+
+export class AuthManager {
+  private static getAuthPath(): string {
+    if (process.env.KEYSTONE_AUTH_PATH) {
+      return process.env.KEYSTONE_AUTH_PATH;
+    }
+    const dir = join(homedir(), '.keystone');
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    return join(dir, 'auth.json');
+  }
+
+  static load(): AuthData {
+    const path = AuthManager.getAuthPath();
+    if (existsSync(path)) {
+      try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+      } catch {
+        return {};
+      }
+    }
+    return {};
+  }
+
+  static save(data: AuthData): void {
+    const path = AuthManager.getAuthPath();
+    const current = AuthManager.load();
+    writeFileSync(path, JSON.stringify({ ...current, ...data }, null, 2));
+  }
+
+  static async getCopilotToken(): Promise<string | undefined> {
+    const auth = AuthManager.load();
+
+    // Check if we have a valid cached token
+    if (
+      auth.copilot_token &&
+      auth.copilot_expires_at &&
+      auth.copilot_expires_at > Date.now() / 1000 + 300
+    ) {
+      return auth.copilot_token;
+    }
+
+    if (!auth.github_token) {
+      return undefined;
+    }
+
+    // Exchange GitHub token for Copilot token
+    try {
+      const response = await fetch('https://api.github.com/copilot_internal/v2/token', {
+        headers: {
+          Authorization: `token ${auth.github_token}`,
+          ...COPILOT_HEADERS,
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to get Copilot token: ${response.statusText}`);
+      }
+
+      const data = (await response.json()) as { token: string; expires_at: number };
+      AuthManager.save({
+        copilot_token: data.token,
+        copilot_expires_at: data.expires_at,
+      });
+
+      return data.token;
+    } catch (error) {
+      console.error('Error refreshing Copilot token:', error);
+      return undefined;
+    }
+  }
+}

package/src/utils/config-loader.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it, afterEach } from 'bun:test';
+import { ConfigLoader } from './config-loader';
+import type { Config } from '../parser/config-schema';
+
+describe('ConfigLoader', () => {
+  afterEach(() => {
+    ConfigLoader.clear();
+  });
+
+  it('should allow setting and clearing config', () => {
+    const mockConfig: Config = {
+      default_provider: 'test',
+      providers: {
+        test: { type: 'openai' },
+      },
+      model_mappings: {},
+      storage: { retention_days: 30 },
+      workflows_directory: 'workflows',
+    };
+
+    ConfigLoader.setConfig(mockConfig);
+    expect(ConfigLoader.load()).toEqual(mockConfig);
+
+    ConfigLoader.clear();
+    // After clear, it will try to load from disk or use defaults
+    const loaded = ConfigLoader.load();
+    expect(loaded).not.toEqual(mockConfig);
+  });
+
+  it('should return correct provider for model', () => {
+    const mockConfig: Config = {
+      default_provider: 'openai',
+      providers: {
+        openai: { type: 'openai' },
+        anthropic: { type: 'anthropic' },
+        copilot: { type: 'copilot' },
+      },
+      model_mappings: {
+        'gpt-*': 'copilot',
+        'claude-v1': 'anthropic',
+      },
+      storage: { retention_days: 30 },
+      workflows_directory: 'workflows',
+    };
+    ConfigLoader.setConfig(mockConfig);
+
+    expect(ConfigLoader.getProviderForModel('gpt-4')).toBe('copilot');
+    expect(ConfigLoader.getProviderForModel('claude-v1')).toBe('anthropic');
+    expect(ConfigLoader.getProviderForModel('unknown')).toBe('openai');
+    expect(ConfigLoader.getProviderForModel('anthropic:claude-3')).toBe('anthropic');
+  });
+});

package/src/utils/config-loader.ts

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import yaml from 'js-yaml';
+import { type Config, ConfigSchema } from '../parser/config-schema';
+
+export class ConfigLoader {
+  private static instance: Config;
+
+  static load(): Config {
+    if (ConfigLoader.instance) return ConfigLoader.instance;
+
+    const configPaths = [
+      join(process.cwd(), '.keystone', 'config.yaml'),
+      join(process.cwd(), '.keystone', 'config.yml'),
+    ];
+
+    let userConfig: Record<string, unknown> = {};
+
+    for (const path of configPaths) {
+      if (existsSync(path)) {
+        try {
+          const content = readFileSync(path, 'utf8');
+          userConfig = (yaml.load(content) as Record<string, unknown>) || {};
+          break;
+        } catch (error) {
+          console.warn(`Warning: Failed to load config from ${path}:`, error);
+        }
+      }
+    }
+
+    const result = ConfigSchema.safeParse(userConfig);
+    if (!result.success) {
+      console.warn('Warning: Invalid configuration, using defaults:', result.error.message);
+      ConfigLoader.instance = ConfigSchema.parse({});
+    } else {
+      ConfigLoader.instance = result.data;
+    }
+
+    return ConfigLoader.instance;
+  }
+
+  /**
+   * For testing purposes, manually set the configuration
+   */
+  static setConfig(config: Config): void {
+    ConfigLoader.instance = config;
+  }
+
+  /**
+   * For testing purposes, clear the cached configuration
+   */
+  static clear(): void {
+    // @ts-ignore - allowing clearing for tests
+    ConfigLoader.instance = undefined;
+  }
+
+  static getProviderForModel(model: string): string {
+    const config = ConfigLoader.load();
+
+    // Check for provider prefix (e.g. "copilot:gpt-4o")
+    if (model.includes(':')) {
+      const [provider] = model.split(':');
+      if (config.providers[provider]) {
+        return provider;
+      }
+    }
+
+    // Check explicit mappings first
+    if (config.model_mappings[model]) {
+      return config.model_mappings[model];
+    }
+
+    // Check glob-style mappings (very basic)
+    for (const [pattern, provider] of Object.entries(config.model_mappings)) {
+      if (pattern.endsWith('*')) {
+        const prefix = pattern.slice(0, -1);
+        if (model.startsWith(prefix)) {
+          return provider;
+        }
+      }
+    }
+
+    return config.default_provider;
+  }
+}

package/src/utils/mermaid.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it, mock } from 'bun:test';
+import type { Workflow } from '../parser/schema';
+import { generateMermaidGraph } from './mermaid';
+
+describe('mermaid', () => {
+  it('should generate a mermaid graph from a workflow', () => {
+    const workflow: Workflow = {
+      name: 'test',
+      steps: [
+        { id: 's1', type: 'shell', run: 'echo 1', needs: [] },
+        { id: 's2', type: 'llm', agent: 'my-agent', prompt: 'hi', needs: ['s1'] },
+        { id: 's3', type: 'human', message: 'ok?', needs: ['s2'], if: 'true' },
+      ],
+    } as unknown as Workflow;
+
+    const graph = generateMermaidGraph(workflow);
+    expect(graph).toContain('graph TD');
+    expect(graph).toContain('s1["s1\\n(shell)"]:::shell');
+    expect(graph).toContain('s2["s2\\n🤖 my-agent"]:::ai');
+    expect(graph).toContain('s3["s3\\n(human)\\n❓ Conditional"]:::human');
+    expect(graph).toContain('s1 --> s2');
+    expect(graph).toContain('s2 --> s3');
+  });
+
+  it('should handle loops in labeling', () => {
+    const workflow: Workflow = {
+      name: 'loop',
+      steps: [{ id: 'l1', type: 'shell', run: 'echo', foreach: '[1,2]', needs: [] }],
+    } as unknown as Workflow;
+    const graph = generateMermaidGraph(workflow);
+    expect(graph).toContain('(📚 Loop)');
+  });
+
+  it('should render mermaid as ascii', async () => {
+    const originalFetch = global.fetch;
+    // @ts-ignore
+    global.fetch = mock(() =>
+      Promise.resolve(
+        new Response('ascii graph', {
+          status: 200,
+        })
+      )
+    );
+
+    const { renderMermaidAsAscii } = await import('./mermaid');
+    const result = await renderMermaidAsAscii('graph TD\n  A --> B');
+    expect(result).toBe('ascii graph');
+
+    global.fetch = originalFetch;
+  });
+});

package/src/utils/mermaid.ts

@@ -0,0 +1,87 @@
+import type { Workflow } from '../parser/schema';
+
+export function generateMermaidGraph(workflow: Workflow): string {
+  const lines = ['graph TD'];
+
+  // 1. Add Nodes
+  for (const step of workflow.steps) {
+    // Sanitize ID for Mermaid
+    const safeId = step.id.replace(/[^a-zA-Z0-9_]/g, '_');
+
+    // Add type icon/label
+    let label = `${step.id}\\n(${step.type})`;
+
+    // Add specific details based on type
+    if (step.type === 'llm') label = `${step.id}\\n🤖 ${step.agent}`;
+    if (step.foreach) label += '\\n(📚 Loop)';
+    if (step.if) label += '\\n❓ Conditional';
+
+    // Styling based on type
+    let style = '';
+    switch (step.type) {
+      case 'llm':
+        style = ':::ai';
+        break;
+      case 'human':
+        style = ':::human';
+        break;
+      case 'shell':
+        style = ':::shell';
+        break;
+      default:
+        style = ':::default';
+    }
+
+    lines.push(`  ${safeId}["${label}"]${style}`);
+  }
+
+  // 2. Add Edges (Dependencies)
+  for (const step of workflow.steps) {
+    const safeId = step.id.replace(/[^a-zA-Z0-9_]/g, '_');
+
+    if (step.needs && step.needs.length > 0) {
+      for (const need of step.needs) {
+        const safeNeed = need.replace(/[^a-zA-Z0-9_]/g, '_');
+        lines.push(`  ${safeNeed} --> ${safeId}`);
+      }
+    }
+  }
+
+  // 3. Define Styles
+  lines.push('  classDef ai fill:#e1f5fe,stroke:#01579b,stroke-width:2px;');
+  lines.push(
+    '  classDef human fill:#fff3e0,stroke:#e65100,stroke-width:2px,stroke-dasharray: 5 5;'
+  );
+  lines.push('  classDef shell fill:#f3e5f5,stroke:#4a148c,stroke-width:1px;');
+  lines.push('  classDef default fill:#fff,stroke:#333,stroke-width:1px;');
+
+  return lines.join('\n');
+}
+
+/**
+ * Renders a Mermaid graph as ASCII using mermaid-ascii.art
+ */
+export async function renderMermaidAsAscii(mermaid: string): Promise<string | null> {
+  try {
+    const response = await fetch('https://mermaid-ascii.art', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: `mermaid=${encodeURIComponent(mermaid)}`,
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const ascii = await response.text();
+    if (ascii.includes('Failed to render diagram')) {
+      return null;
+    }
+
+    return ascii;
+  } catch {
+    return null;
+  }
+}