aigroup-workflow 1.0.0

package/skills/jarvis/claude-simone/mcp-server/src/config/types.ts

@@ -0,0 +1,176 @@
+/**
+ * Configuration types for Simone MCP Server
+ * Supports both single-project and multi-context configurations
+ */
+
+export interface ProjectConfig {
+  project: ProjectMetadata;
+  contexts: ProjectContext[];
+  shared?: SharedConfig;
+  github?: GitHubConfig;
+  features?: FeaturesConfig;
+}
+
+export interface ProjectMetadata {
+  name: string;
+  description?: string;
+  type?: 'single' | 'monorepo';
+  version?: string;
+  riskLevel?: number; // 1-10 scale: 1=careful, 5=balanced, 10=risky
+}
+
+export interface ProjectContext {
+  name: string;
+  path: string;
+  stack?: StackConfig;
+  tooling?: ToolingConfig;
+  methodology?: MethodologyConfig;
+  github?: GitHubConfig; // Context can override project-level GitHub settings
+  // Allow custom properties
+  [key: string]: any;
+}
+
+export interface SharedConfig {
+  tooling?: ToolingConfig;
+  methodology?: MethodologyConfig;
+  // Allow custom properties
+  [key: string]: any;
+}
+
+export interface StackConfig {
+  language?: string;
+  framework?: FrameworkConfig;
+  database?: DatabaseConfig;
+  styling?: StylingConfig;
+  // Allow custom stack properties
+  [key: string]: any;
+}
+
+export interface FrameworkConfig extends FeatureConfig {
+  name?: string;
+  version?: string;
+}
+
+export interface DatabaseConfig extends FeatureConfig {
+  type?: string;
+  orm?: string;
+}
+
+export interface StylingConfig extends FeatureConfig {
+  system?: string;
+}
+
+export interface ToolingConfig {
+  lint?: ToolConfig;
+  test?: TestConfig;
+  format?: FormatConfig;
+  commit?: CommitConfig;
+  // Allow custom tooling entries
+  [key: string]: FeatureConfig | undefined;
+}
+
+export interface FeatureConfig {
+  enabled: boolean;
+  command?: string;
+  // Allow custom properties per feature
+  [key: string]: any;
+}
+
+export interface ToolConfig extends FeatureConfig {
+  autofix?: string;
+  config?: string;
+}
+
+export interface TestConfig extends FeatureConfig {
+  coverage?: string;
+  watch?: string;
+}
+
+export interface FormatConfig extends FeatureConfig {
+  check?: string;
+  config?: string;
+}
+
+export interface CommitConfig extends FeatureConfig {
+  // No additional properties yet
+}
+
+export interface MethodologyConfig {
+  development?: 'tdd' | 'bdd' | 'none' | string;
+  architecture?: 'clean' | 'mvc' | 'microservices' | 'none' | string;
+  workflow?: 'gitflow' | 'github-flow' | 'trunk-based' | 'none' | string;
+  // Allow custom methodology properties
+  [key: string]: any;
+}
+
+/**
+ * Helper type to extract feature paths from config
+ */
+export type FeaturePath = 
+  | `tooling.${string}`
+  | `stack.${string}`
+  | `methodology.${string}`
+  | string;
+
+/**
+ * GitHub integration configuration
+ */
+export interface GitHubConfig {
+  repository: string;  // owner/repo format
+  tool?: 'mcp' | 'cli';  // default to 'cli' if not specified
+  defaultLabels?: string[];  // labels to apply to new issues
+  github_projects?: GitHubProjectsConfig;  // optional GitHub Projects integration
+  // Allow custom GitHub properties
+  [key: string]: any;
+}
+
+/**
+ * GitHub Projects integration configuration
+ */
+export interface GitHubProjectsConfig {
+  enabled: boolean;           // whether Projects integration is enabled
+  project_id: string;         // GitHub Project ID
+  idea_status: string;        // status for draft/idea items
+  work_status: string;        // status for items to pull from work queue
+  new_issue_status: string;   // status for newly created issues
+  available_statuses?: string[];  // cached list of available statuses
+}
+
+/**
+ * Features configuration for optional functionality
+ */
+export interface FeaturesConfig {
+  pr_review_wait?: PrReviewWaitConfig;
+  /**
+   * Workflow-related toggles.
+   * Defaults (e.g., autoCommit = true) are applied when not specified.
+   */
+  workflow?: WorkflowConfig;
+}
+
+/**
+ * Workflow configuration for development process
+ */
+export interface WorkflowConfig {
+  autoCommit?: boolean;  // whether to auto-commit and create PR after implementation (default: true)
+}
+
+/**
+ * PR review wait feature configuration
+ */
+export interface PrReviewWaitConfig {
+  enabled: boolean;
+  initial_wait?: number;   // seconds before first check (default: 30)
+  poll_interval?: number;  // seconds between checks (default: 30)
+  timeout?: number;        // max wait time in seconds (default: 600)
+  auto_merge?: boolean;    // whether to auto-merge if approved (default: false)
+}
+
+/**
+ * Context with resolved configuration
+ */
+export interface ResolvedContext extends ProjectContext {
+  // Merged with shared config if applicable
+  resolvedTooling?: ToolingConfig;
+  resolvedMethodology?: MethodologyConfig;
+}

package/skills/jarvis/claude-simone/mcp-server/src/index.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+  type GetPromptResult,
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { watch } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+import { getEnvConfig } from './config/index.js';
+import { initializeTemplating } from './templates/index.js';
+import { initializeLogger, logError, logDebug } from './utils/logger.js';
+import { ActivityLogger } from './tools/activity-logger/index.js';
+import { getTools, getToolSchemas, handleToolCall, type ToolContext } from './tools/index.js';
+import { DatabaseConnection } from './tools/database.js';
+import type Database from 'better-sqlite3';
+
+// Get configuration
+const config = getEnvConfig();
+
+// Initialize logger
+initializeLogger(config.projectPath);
+
+// Initialize templating system
+const promptHandler = initializeTemplating(config.projectPath);
+
+// Initialize database connection
+let databaseConnection: DatabaseConnection;
+let database: Database.Database;
+
+try {
+  databaseConnection = new DatabaseConnection(config.projectPath);
+  database = databaseConnection.getDb();
+  logDebug('Database connection initialized successfully').catch(() => {});
+} catch (error) {
+  const errorMessage = `CRITICAL DATABASE ERROR: Failed to initialize database connection: ${error instanceof Error ? error.message : String(error)}`;
+  void logError(new Error(errorMessage)).then(() => {
+    console.error(errorMessage); // Also output to console for immediate visibility
+    process.exit(1);
+  });
+  throw error; // This will never be reached but satisfies TypeScript
+}
+
+// Initialize tool context
+const toolContext: ToolContext = {
+  projectPath: config.projectPath,
+  activityLogger: new ActivityLogger(config.projectPath, database),
+  database,
+};
+
+// Get available tools
+const tools = getTools(toolContext);
+
+// Create server instance
+const server = new Server(
+  {
+    name: 'simone-mcp',
+    version: '0.1.0',
+  },
+  {
+    capabilities: {
+      prompts: {
+        listChanged: true,
+      },
+      tools: {},
+    },
+  },
+);
+
+// Handle prompt listing
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  const availablePrompts = await promptHandler.listAvailablePrompts();
+  
+  // Convert to MCP format
+  const prompts = availablePrompts.map(p => ({
+    name: p.name,
+    description: p.description,
+    arguments: p.arguments?.map(arg => ({
+      name: arg.name,
+      description: arg.description,
+      required: arg.required || false,
+    })),
+  }));
+
+  return { prompts };
+});
+
+// Handle prompt retrieval
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  const messages = await promptHandler.getPromptMessages(name, args || {});
+  
+  return {
+    messages,
+  } as GetPromptResult;
+});
+
+// Handle tool listing
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: getToolSchemas(tools),
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  
+  return handleToolCall(name, args || {}, tools, toolContext);
+});
+
+// Watch for prompt changes
+async function watchPrompts() {
+  const projectPromptsDir = join(config.projectPath, '.simone', 'prompts');
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const builtInPromptsDir = join(__dirname, 'templates', 'prompts');
+  
+  const watchDir = async (dir: string) => {
+    try {
+      watch(dir, { recursive: true }, (_eventType, filename) => {
+        if (filename && (filename.endsWith('.yaml') || filename.endsWith('.hbs'))) {
+          // Log asynchronously without blocking
+          logDebug(`Detected change in: ${filename}`).catch(() => {});
+          
+          // Clear the template cache
+          promptHandler.clearCache();
+          
+          // Send notification that prompts have changed
+          server.notification({
+            method: 'notifications/prompts/list_changed',
+            params: {},
+          }).then(() => {
+            logDebug('Sent prompts/list_changed notification').catch(() => {});
+          }).catch((error) => {
+            logError(`Failed to send notification: ${error}`).catch(() => {});
+          });
+        }
+      });
+      await logDebug(`Watching directory: ${dir}`);
+    } catch (_error) {
+      await logDebug(`Could not watch directory: ${dir} (this is okay if it doesn't exist)`);
+    }
+  };
+  
+  await watchDir(projectPromptsDir);
+  
+  // Only watch built-in prompts in development
+  if (process.env['NODE_ENV'] !== 'production') {
+    await watchDir(builtInPromptsDir);
+  }
+}
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  
+  // Start watching for prompt changes
+  await watchPrompts();
+  await logDebug('Server started with prompt hot-reload enabled');
+  
+  // Server started successfully
+}
+
+main().catch(async (error) => {
+  await logError(error instanceof Error ? error : new Error(String(error)));
+  process.exit(1);
+});
+
+// Cleanup on exit
+const handleShutdown = async (signal: string) => {
+  try {
+    await logDebug(`Received ${signal}, shutting down server...`);
+    if (databaseConnection) {
+      databaseConnection.close();
+      await logDebug('Database connection closed');
+    }
+    process.exit(0);
+  } catch (error) {
+    console.error('Error during shutdown:', error);
+    process.exit(1);
+  }
+};
+
+process.on('SIGINT', () => handleShutdown('SIGINT'));
+process.on('SIGTERM', () => handleShutdown('SIGTERM'));

package/skills/jarvis/claude-simone/mcp-server/src/templates/context.ts

@@ -0,0 +1,25 @@
+import { basename } from 'path';
+import type { TemplateContext } from '../types/prompt.js';
+
+export function buildTemplateContext(
+  projectPath: string,
+  args: Record<string, any> = {}
+): TemplateContext {
+  // Get project name from path
+  const projectName = basename(projectPath);
+  
+  // Create date/time information
+  const now = new Date();
+  const timestamp = now.toISOString();
+  const currentDate = now.toLocaleDateString();
+  const currentTime = now.toLocaleTimeString();
+  
+  return {
+    PROJECT_PATH: projectPath,
+    PROJECT_NAME: projectName,
+    TIMESTAMP: timestamp,
+    CURRENT_DATE: currentDate,
+    CURRENT_TIME: currentTime,
+    ...args, // Merge in any user arguments
+  };
+}