kontext-ai 0.1.0

package/src/database/syncEvents.ts

@@ -0,0 +1,89 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getDatabase } from './index';
+
+export interface SyncEventRow {
+  id: string;
+  timestamp: string;
+  action: string;
+  entity_type: string;
+  entity_id: string;
+  entity_name: string;
+  tool_name: string | null;
+  status: string;
+  error: string | null;
+}
+
+export interface CreateSyncEventInput {
+  action: 'created' | 'updated' | 'deleted' | 'synced';
+  entityType: 'context_file' | 'tool_config' | 'skill';
+  entityId: string;
+  entityName: string;
+  toolName?: string;
+  status: 'success' | 'pending' | 'failed';
+  error?: string;
+}
+
+export function createSyncEvent(input: CreateSyncEventInput): SyncEventRow {
+  const db = getDatabase();
+  const id = uuidv4();
+  const now = new Date().toISOString();
+
+  const stmt = db.prepare(`
+    INSERT INTO sync_events (id, timestamp, action, entity_type, entity_id, entity_name, tool_name, status, error)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  stmt.run(
+    id,
+    now,
+    input.action,
+    input.entityType,
+    input.entityId,
+    input.entityName,
+    input.toolName || null,
+    input.status,
+    input.error || null
+  );
+
+  return getSyncEventById(id)!;
+}
+
+export function getSyncEventById(id: string): SyncEventRow | undefined {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM sync_events WHERE id = ?');
+  return stmt.get(id) as SyncEventRow | undefined;
+}
+
+export function getAllSyncEvents(limit = 100): SyncEventRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM sync_events ORDER BY timestamp DESC LIMIT ?');
+  return stmt.all(limit) as SyncEventRow[];
+}
+
+export function getSyncEventsByEntity(entityType: string, entityId: string): SyncEventRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM sync_events WHERE entity_type = ? AND entity_id = ? ORDER BY timestamp DESC');
+  return stmt.all(entityType, entityId) as SyncEventRow[];
+}
+
+export function getRecentSyncEvents(limit = 10): SyncEventRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM sync_events ORDER BY timestamp DESC LIMIT ?');
+  return stmt.all(limit) as SyncEventRow[];
+}
+
+export function getFailedSyncEvents(): SyncEventRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM sync_events WHERE status = ? ORDER BY timestamp DESC');
+  return stmt.all('failed') as SyncEventRow[];
+}
+
+export function clearOldSyncEvents(daysToKeep = 30): number {
+  const db = getDatabase();
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - daysToKeep);
+  
+  const stmt = db.prepare('DELETE FROM sync_events WHERE timestamp < ?');
+  const result = stmt.run(cutoff.toISOString());
+  return result.changes;
+}

package/src/database/toolConfigs.ts

@@ -0,0 +1,101 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getDatabase } from './index';
+
+export interface ToolConfigRow {
+  id: string;
+  tool_name: string;
+  tool_type: string;
+  connection_status: string;
+  last_used: string | null;
+  config: string;
+}
+
+export interface CreateToolConfigInput {
+  toolName: string;
+  toolType: 'mcp' | 'web' | 'cli' | 'api';
+  config?: Record<string, unknown>;
+}
+
+export interface UpdateToolConfigInput {
+  connectionStatus?: 'connected' | 'disconnected' | 'pending';
+  config?: Record<string, unknown>;
+}
+
+export function createToolConfig(input: CreateToolConfigInput): ToolConfigRow {
+  const db = getDatabase();
+  const id = uuidv4();
+  const now = new Date().toISOString();
+
+  const stmt = db.prepare(`
+    INSERT INTO tool_configs (id, tool_name, tool_type, connection_status, last_used, config)
+    VALUES (?, ?, ?, 'pending', ?, ?)
+  `);
+
+  stmt.run(id, input.toolName, input.toolType, now, JSON.stringify(input.config || {}));
+
+  return getToolConfigByName(input.toolName)!;
+}
+
+export function getToolConfigById(id: string): ToolConfigRow | undefined {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM tool_configs WHERE id = ?');
+  return stmt.get(id) as ToolConfigRow | undefined;
+}
+
+export function getToolConfigByName(name: string): ToolConfigRow | undefined {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM tool_configs WHERE tool_name = ?');
+  return stmt.get(name) as ToolConfigRow | undefined;
+}
+
+export function getAllToolConfigs(): ToolConfigRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM tool_configs ORDER BY last_used DESC');
+  return stmt.all() as ToolConfigRow[];
+}
+
+export function getConnectedTools(): ToolConfigRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM tool_configs WHERE connection_status = ? ORDER BY last_used DESC');
+  return stmt.all('connected') as ToolConfigRow[];
+}
+
+export function updateToolConfig(id: string, input: UpdateToolConfigInput): ToolConfigRow | undefined {
+  const db = getDatabase();
+  const existing = getToolConfigById(id);
+  if (!existing) return undefined;
+
+  const updates: string[] = [];
+  const params: (string)[] = [];
+
+  if (input.connectionStatus !== undefined) {
+    updates.push('connection_status = ?');
+    params.push(input.connectionStatus);
+  }
+  if (input.config !== undefined) {
+    updates.push('config = ?');
+    params.push(JSON.stringify(input.config));
+  }
+
+  if (updates.length === 0) return existing;
+
+  params.push(id);
+
+  const stmt = db.prepare(`UPDATE tool_configs SET ${updates.join(', ')} WHERE id = ?`);
+  stmt.run(...params);
+
+  return getToolConfigById(id);
+}
+
+export function deleteToolConfig(id: string): boolean {
+  const db = getDatabase();
+  const stmt = db.prepare('DELETE FROM tool_configs WHERE id = ?');
+  const result = stmt.run(id);
+  return result.changes > 0;
+}
+
+export function updateLastUsed(id: string): void {
+  const db = getDatabase();
+  const stmt = db.prepare('UPDATE tool_configs SET last_used = ? WHERE id = ?');
+  stmt.run(new Date().toISOString(), id);
+}

package/src/database/webhooks.ts

@@ -0,0 +1,117 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getDatabase } from './index';
+
+export interface WebhookRow {
+  id: string;
+  url: string;
+  name: string;
+  events: string;
+  active: number;
+  last_triggered: string | null;
+  created_at: string;
+}
+
+export interface CreateWebhookInput {
+  url: string;
+  name: string;
+  events: string[];
+}
+
+export interface UpdateWebhookInput {
+  url?: string;
+  name?: string;
+  events?: string[];
+  active?: boolean;
+}
+
+export function createWebhook(input: CreateWebhookInput): WebhookRow {
+  const db = getDatabase();
+  const id = uuidv4();
+  const now = new Date().toISOString();
+
+  const stmt = db.prepare(`
+    INSERT INTO webhooks (id, url, name, events, active, created_at)
+    VALUES (?, ?, ?, ?, 1, ?)
+  `);
+
+  stmt.run(id, input.url, input.name, JSON.stringify(input.events), now);
+
+  return getWebhookById(id)!;
+}
+
+export function getWebhookById(id: string): WebhookRow | undefined {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM webhooks WHERE id = ?');
+  return stmt.get(id) as WebhookRow | undefined;
+}
+
+export function getAllWebhooks(): WebhookRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM webhooks ORDER BY created_at DESC');
+  return stmt.all() as WebhookRow[];
+}
+
+export function getActiveWebhooks(): WebhookRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM webhooks WHERE active = 1 ORDER BY created_at DESC');
+  return stmt.all() as WebhookRow[];
+}
+
+export function getWebhooksByEvent(event: string): WebhookRow[] {
+  const db = getDatabase();
+  const stmt = db.prepare('SELECT * FROM webhooks WHERE active = 1');
+  const all = stmt.all() as WebhookRow[];
+  
+  return all.filter(webhook => {
+    const events = JSON.parse(webhook.events) as string[];
+    return events.includes(event);
+  });
+}
+
+export function updateWebhook(id: string, input: UpdateWebhookInput): WebhookRow | undefined {
+  const db = getDatabase();
+  const existing = getWebhookById(id);
+  if (!existing) return undefined;
+
+  const updates: string[] = [];
+  const params: (string | number)[] = [];
+
+  if (input.url !== undefined) {
+    updates.push('url = ?');
+    params.push(input.url);
+  }
+  if (input.name !== undefined) {
+    updates.push('name = ?');
+    params.push(input.name);
+  }
+  if (input.events !== undefined) {
+    updates.push('events = ?');
+    params.push(JSON.stringify(input.events));
+  }
+  if (input.active !== undefined) {
+    updates.push('active = ?');
+    params.push(input.active ? 1 : 0);
+  }
+
+  if (updates.length === 0) return existing;
+
+  params.push(id);
+
+  const stmt = db.prepare(`UPDATE webhooks SET ${updates.join(', ')} WHERE id = ?`);
+  stmt.run(...params);
+
+  return getWebhookById(id);
+}
+
+export function deleteWebhook(id: string): boolean {
+  const db = getDatabase();
+  const stmt = db.prepare('DELETE FROM webhooks WHERE id = ?');
+  const result = stmt.run(id);
+  return result.changes > 0;
+}
+
+export function markWebhookTriggered(id: string): void {
+  const db = getDatabase();
+  const stmt = db.prepare('UPDATE webhooks SET last_triggered = ? WHERE id = ?');
+  stmt.run(new Date().toISOString(), id);
+}

package/src/graphql/resolvers.ts

@@ -0,0 +1,357 @@
+import { PubSub } from 'graphql-subscriptions';
+import {
+  createContextFile,
+  getContextFileById,
+  getAllContextFiles,
+  getContextFilesByType,
+  getContextFilesByTool,
+  updateContextFile,
+  deleteContextFile,
+  searchContextFiles,
+  CreateContextFileInput,
+  UpdateContextFileInput
+} from '../database/contextFiles';
+import {
+  createToolConfig,
+  getToolConfigById,
+  getAllToolConfigs,
+  getConnectedTools,
+  updateToolConfig,
+  deleteToolConfig,
+  updateLastUsed,
+  CreateToolConfigInput,
+  UpdateToolConfigInput
+} from '../database/toolConfigs';
+import {
+  createSkill,
+  getSkillById,
+  getAllSkills,
+  getSkillsByCategory,
+  updateSkill,
+  deleteSkill,
+  searchSkills,
+  CreateSkillInput,
+  UpdateSkillInput
+} from '../database/skills';
+import {
+  createSyncEvent,
+  getAllSyncEvents,
+  getRecentSyncEvents,
+  getFailedSyncEvents,
+  CreateSyncEventInput
+} from '../database/syncEvents';
+import {
+  createWebhook,
+  getWebhookById,
+  getAllWebhooks,
+  getActiveWebhooks,
+  getWebhooksByEvent,
+  updateWebhook,
+  deleteWebhook,
+  CreateWebhookInput,
+  UpdateWebhookInput
+} from '../database/webhooks';
+import {
+  getConfig,
+  setConfig,
+  getAllConfig,
+  deleteConfig
+} from '../database/config';
+
+export const pubsub = new PubSub();
+
+const CONTEXT_FILE_CHANGED = 'CONTEXT_FILE_CHANGED';
+const SKILL_CHANGED = 'SKILL_CHANGED';
+const TOOL_CONFIG_CHANGED = 'TOOL_CONFIG_CHANGED';
+const SYNC_EVENT_OCCURRED = 'SYNC_EVENT_OCCURRED';
+
+interface ContextFileArgs {
+  id: string;
+}
+
+interface ContextFilesArgs {
+  type?: string;
+  tool?: string;
+}
+
+interface SearchArgs {
+  query: string;
+}
+
+interface SyncEventsArgs {
+  limit?: number;
+}
+
+interface ConfigArgs {
+  key?: string;
+}
+
+export const resolvers = {
+  Query: {
+    contextFiles: (_: unknown, args: ContextFilesArgs) => {
+      if (args.tool) {
+        return getContextFilesByTool(args.tool);
+      }
+      if (args.type) {
+        return getContextFilesByType(args.type);
+      }
+      return getAllContextFiles();
+    },
+    contextFile: (_: unknown, args: ContextFileArgs) => {
+      return getContextFileById(args.id);
+    },
+    searchContextFiles: (_: unknown, args: SearchArgs) => {
+      return searchContextFiles(args.query);
+    },
+    toolConfigs: () => {
+      return getAllToolConfigs();
+    },
+    toolConfig: (_: unknown, args: ContextFileArgs) => {
+      return getToolConfigById(args.id);
+    },
+    connectedTools: () => {
+      return getConnectedTools();
+    },
+    skills: (_: unknown, args: { category?: string }) => {
+      if (args.category) {
+        return getSkillsByCategory(args.category);
+      }
+      return getAllSkills();
+    },
+    skill: (_: unknown, args: ContextFileArgs) => {
+      return getSkillById(args.id);
+    },
+    searchSkills: (_: unknown, args: SearchArgs) => {
+      return searchSkills(args.query);
+    },
+    syncEvents: (_: unknown, args: SyncEventsArgs) => {
+      return getAllSyncEvents(args.limit || 100);
+    },
+    recentSyncEvents: (_: unknown, args: SyncEventsArgs) => {
+      return getRecentSyncEvents(args.limit || 10);
+    },
+    failedSyncEvents: () => {
+      return getFailedSyncEvents();
+    },
+    webhooks: () => {
+      return getAllWebhooks();
+    },
+    webhook: (_: unknown, args: ContextFileArgs) => {
+      return getWebhookById(args.id);
+    },
+    config: (_: unknown, args: ConfigArgs) => {
+      if (args.key) {
+        const value = getConfig(args.key);
+        return value !== undefined ? JSON.stringify(value) : null;
+      }
+      return JSON.stringify(getAllConfig());
+    }
+  },
+  Mutation: {
+    createContextFile: (_: unknown, args: { input: CreateContextFileInput }) => {
+      const result = createContextFile(args.input);
+      pubsub.publish(CONTEXT_FILE_CHANGED, { contextFileChanged: result });
+      
+      createSyncEvent({
+        action: 'created',
+        entityType: 'context_file',
+        entityId: result.id,
+        entityName: result.name,
+        status: 'success'
+      });
+      
+      return result;
+    },
+    updateContextFile: (_: unknown, args: { id: string; input: UpdateContextFileInput }) => {
+      const result = updateContextFile(args.id, args.input);
+      if (result) {
+        pubsub.publish(CONTEXT_FILE_CHANGED, { contextFileChanged: result });
+        
+        createSyncEvent({
+          action: 'updated',
+          entityType: 'context_file',
+          entityId: result.id,
+          entityName: result.name,
+          status: 'success'
+        });
+      }
+      return result;
+    },
+    deleteContextFile: (_: unknown, args: ContextFileArgs) => {
+      const existing = getContextFileById(args.id);
+      const result = deleteContextFile(args.id);
+      if (result && existing) {
+        createSyncEvent({
+          action: 'deleted',
+          entityType: 'context_file',
+          entityId: args.id,
+          entityName: existing.name,
+          status: 'success'
+        });
+      }
+      return result;
+    },
+    createToolConfig: (_: unknown, args: { input: CreateToolConfigInput }) => {
+      const result = createToolConfig(args.input);
+      pubsub.publish(TOOL_CONFIG_CHANGED, { toolConfigChanged: result });
+      return result;
+    },
+    updateToolConfig: (_: unknown, args: { id: string; input: UpdateToolConfigInput }) => {
+      const result = updateToolConfig(args.id, args.input);
+      if (result) {
+        pubsub.publish(TOOL_CONFIG_CHANGED, { toolConfigChanged: result });
+      }
+      return result;
+    },
+    deleteToolConfig: (_: unknown, args: ContextFileArgs) => {
+      return deleteToolConfig(args.id);
+    },
+    updateToolLastUsed: (_: unknown, args: ContextFileArgs) => {
+      updateLastUsed(args.id);
+      return true;
+    },
+    createSkill: (_: unknown, args: { input: CreateSkillInput }) => {
+      const result = createSkill(args.input);
+      pubsub.publish(SKILL_CHANGED, { skillChanged: result });
+      
+      createSyncEvent({
+        action: 'created',
+        entityType: 'skill',
+        entityId: result.id,
+        entityName: result.name,
+        status: 'success'
+      });
+      
+      return result;
+    },
+    updateSkill: (_: unknown, args: { id: string; input: UpdateSkillInput }) => {
+      const result = updateSkill(args.id, args.input);
+      if (result) {
+        pubsub.publish(SKILL_CHANGED, { skillChanged: result });
+        
+        createSyncEvent({
+          action: 'updated',
+          entityType: 'skill',
+          entityId: result.id,
+          entityName: result.name,
+          status: 'success'
+        });
+      }
+      return result;
+    },
+    deleteSkill: (_: unknown, args: ContextFileArgs) => {
+      const existing = getSkillById(args.id);
+      const result = deleteSkill(args.id);
+      if (result && existing) {
+        createSyncEvent({
+          action: 'deleted',
+          entityType: 'skill',
+          entityId: args.id,
+          entityName: existing.name,
+          status: 'success'
+        });
+      }
+      return result;
+    },
+    createWebhook: (_: unknown, args: { input: CreateWebhookInput }) => {
+      return createWebhook(args.input);
+    },
+    updateWebhook: (_: unknown, args: { id: string; input: UpdateWebhookInput }) => {
+      return updateWebhook(args.id, args.input);
+    },
+    deleteWebhook: (_: unknown, args: ContextFileArgs) => {
+      return deleteWebhook(args.id);
+    },
+    setConfig: (_: unknown, args: { key: string; value: string }) => {
+      try {
+        const parsed = JSON.parse(args.value);
+        setConfig(args.key, parsed);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    deleteConfig: (_: unknown, args: { key: string }) => {
+      return deleteConfig(args.key);
+    }
+  },
+  Subscription: {
+    contextFileChanged: {
+      subscribe: () => {
+        return (async function* () {
+          yield { contextFileChanged: {} };
+        })();
+      }
+    },
+    skillChanged: {
+      subscribe: () => {
+        return (async function* () {
+          yield { skillChanged: {} };
+        })();
+      }
+    },
+    toolConfigChanged: {
+      subscribe: () => {
+        return (async function* () {
+          yield { toolConfigChanged: {} };
+        })();
+      }
+    },
+    syncEventOccurred: {
+      subscribe: () => {
+        return (async function* () {
+          yield { syncEventOccurred: {} };
+        })();
+      }
+    }
+  },
+  ContextFile: {
+    id: (parent: { id: string }) => parent.id,
+    name: (parent: { name: string }) => parent.name,
+    type: (parent: { type: string }) => parent.type,
+    tool: (parent: { tool: string | null }) => parent.tool,
+    content: (parent: { content: string }) => parent.content,
+    format: (parent: { format: string }) => parent.format,
+    version: (parent: { version: number }) => parent.version,
+    createdAt: (parent: { created_at: string }) => parent.created_at,
+    updatedAt: (parent: { updated_at: string }) => parent.updated_at
+  },
+  ToolConfig: {
+    id: (parent: { id: string }) => parent.id,
+    toolName: (parent: { tool_name: string }) => parent.tool_name,
+    toolType: (parent: { tool_type: string }) => parent.tool_type,
+    connectionStatus: (parent: { connection_status: string }) => parent.connection_status,
+    lastUsed: (parent: { last_used: string | null }) => parent.last_used,
+    config: (parent: { config: string }) => parent.config
+  },
+  Skill: {
+    id: (parent: { id: string }) => parent.id,
+    name: (parent: { name: string }) => parent.name,
+    description: (parent: { description: string | null }) => parent.description,
+    content: (parent: { content: string }) => parent.content,
+    category: (parent: { category: string }) => parent.category,
+    tags: (parent: { tags: string }) => JSON.parse(parent.tags),
+    createdAt: (parent: { created_at: string }) => parent.created_at,
+    updatedAt: (parent: { updated_at: string }) => parent.updated_at
+  },
+  SyncEvent: {
+    id: (parent: { id: string }) => parent.id,
+    timestamp: (parent: { timestamp: string }) => parent.timestamp,
+    action: (parent: { action: string }) => parent.action,
+    entityType: (parent: { entity_type: string }) => parent.entity_type,
+    entityId: (parent: { entity_id: string }) => parent.entity_id,
+    entityName: (parent: { entity_name: string }) => parent.entity_name,
+    toolName: (parent: { tool_name: string | null }) => parent.tool_name,
+    status: (parent: { status: string }) => parent.status,
+    error: (parent: { error: string | null }) => parent.error
+  },
+  Webhook: {
+    id: (parent: { id: string }) => parent.id,
+    url: (parent: { url: string }) => parent.url,
+    name: (parent: { name: string }) => parent.name,
+    events: (parent: { events: string }) => JSON.parse(parent.events),
+    active: (parent: { active: number }) => parent.active === 1,
+    lastTriggered: (parent: { last_triggered: string | null }) => parent.last_triggered,
+    createdAt: (parent: { created_at: string }) => parent.created_at
+  }
+};