@polymorphism-tech/morph-spec 4.3.6 → 4.5.0

package/src/llm/analyzer.js

@@ -1,215 +0,0 @@
-/**
- * @fileoverview LLMAnalyzer - Analyzes project context using Claude Code's LLM
- * @module morph-spec/llm/analyzer
- */
-
-import { spawn } from 'child_process';
-import { detectClaudeCode, isInteractive } from './environment-detector.js';
-import { buildPrompt } from './prompt-builder.js';
-import Ajv from 'ajv';
-import projectConfigSchema from './project-config-schema.json' with { type: 'json' };
-
-/**
- * @typedef {import('../types/index.js').SanitizedContext} SanitizedContext
- * @typedef {import('../types/index.js').ProjectConfig} ProjectConfig
- */
-
-/**
- * LLM Analysis Error
- */
-export class LLMAnalysisError extends Error {
-  constructor(message, statusCode = 500, attempts = 0, originalError = null) {
-    super(message);
-    this.name = 'LLMAnalysisError';
-    this.statusCode = statusCode;
-    this.attempts = attempts;
-    this.originalError = originalError;
-  }
-}
-
-/**
- * Validation Error
- */
-export class ValidationError extends Error {
-  constructor(message, field, value, schema = null) {
-    super(message);
-    this.name = 'ValidationError';
-    this.field = field;
-    this.value = value;
-    this.schema = schema;
-  }
-}
-
-/**
- * LLMAnalyzer - Analyzes project context using Claude Code's embedded LLM
- * @class
- */
-export class LLMAnalyzer {
-  constructor() {
-    this.ajv = new Ajv({ allErrors: true });
-    this.validateSchema = this.ajv.compile(projectConfigSchema);
-  }
-
-  /**
-   * Analyze project context using Claude Code's LLM
-   * @param {SanitizedContext} context - Sanitized project context
-   * @param {Object} [options] - Analysis options
-   * @param {number} [options.timeout] - Timeout in ms (default: 60000 for user, no timeout for LLM)
-   * @returns {Promise<ProjectConfig>}
-   * @throws {LLMAnalysisError} If analysis fails
-   */
-  async analyze(context, options = {}) {
-    // Check if Claude Code is available
-    if (!detectClaudeCode()) {
-      throw new LLMAnalysisError(
-        'Claude Code environment not detected. This feature requires Claude Code CLI.',
-        503,
-        0
-      );
-    }
-
-    // Build the prompt
-    const prompt = buildPrompt(context);
-
-    // Determine timeout: 60s for interactive (user present), no timeout for LLM-only
-    const timeout = options.timeout || (isInteractive() ? 60000 : 0);
-
-    // Invoke Claude Code LLM
-    const response = await this.invokeLLM(prompt, { timeout });
-
-    // Parse and validate JSON response
-    const projectConfig = this.parseJsonResponse(response);
-
-    return projectConfig;
-  }
-
-  /**
-   * Build structured prompt for LLM
-   * @param {SanitizedContext} context - Sanitized context
-   * @returns {string} Prompt text
-   */
-  buildPrompt(context) {
-    return buildPrompt(context);
-  }
-
-  /**
-   * Invoke Claude Code's LLM via spawning a subprocess
-   *
-   * IMPLEMENTATION NOTE: This is a placeholder implementation.
-   * The actual Claude Code invocation mechanism depends on how Claude Code exposes its LLM.
-   *
-   * Possible approaches:
-   * 1. Spawn `claude` CLI with a special flag for JSON mode
-   * 2. Use an internal API/IPC mechanism
-   * 3. Write prompt to a temp file and invoke Claude Code agent
-   *
-   * For now, we'll simulate the response for testing purposes.
-   *
-   * @param {string} prompt - Prompt text
-   * @param {Object} options - Invocation options
-   * @param {number} options.timeout - Timeout in ms (0 = no timeout)
-   * @returns {Promise<string>} JSON response from LLM
-   * @throws {LLMAnalysisError}
-   */
-  async invokeLLM(prompt, options = {}) {
-    return new Promise((resolve, reject) => {
-      // TODO: Replace with actual Claude Code invocation
-      // For now, this is a placeholder that would need to be implemented
-      // based on how Claude Code exposes its LLM for programmatic access
-
-      // Example approach (pseudo-code):
-      // const claudeProcess = spawn('claude', ['--mode=json', '--prompt', prompt]);
-
-      // Placeholder: Simulate a timeout if needed
-      const { timeout } = options;
-
-      let output = '';
-      let errorOutput = '';
-
-      // Simulated response for testing (to be replaced with actual Claude Code invocation)
-      // In real implementation, this would spawn Claude Code process:
-      /*
-      const claudeProcess = spawn('claude-code', [
-        '--json',
-        '--prompt-from-stdin'
-      ]);
-
-      claudeProcess.stdin.write(prompt);
-      claudeProcess.stdin.end();
-
-      claudeProcess.stdout.on('data', (data) => {
-        output += data.toString();
-      });
-
-      claudeProcess.stderr.on('data', (data) => {
-        errorOutput += data.toString();
-      });
-
-      claudeProcess.on('close', (code) => {
-        if (code !== 0) {
-          reject(new LLMAnalysisError(
-            `Claude Code exited with code ${code}: ${errorOutput}`,
-            500,
-            1
-          ));
-          return;
-        }
-
-        resolve(output);
-      });
-
-      if (timeout > 0) {
-        setTimeout(() => {
-          claudeProcess.kill();
-          reject(new LLMAnalysisError('LLM analysis timeout', 504, 1));
-        }, timeout);
-      }
-      */
-
-      // For now, reject with a "not implemented" error
-      // This will be replaced when we know the exact Claude Code invocation mechanism
-      reject(new LLMAnalysisError(
-        'LLM invocation not yet implemented. Awaiting Claude Code API documentation.',
-        501,
-        0
-      ));
-    });
-  }
-
-  /**
-   * Parse and validate LLM JSON response
-   * @param {string} response - Raw LLM response
-   * @returns {ProjectConfig}
-   * @throws {ValidationError} If response doesn't match schema
-   */
-  parseJsonResponse(response) {
-    // Try to parse JSON
-    let parsed;
-    try {
-      parsed = JSON.parse(response);
-    } catch (error) {
-      throw new ValidationError(
-        'LLM response is not valid JSON',
-        'response',
-        response,
-        null
-      );
-    }
-
-    // Validate against schema
-    const valid = this.validateSchema(parsed);
-    if (!valid) {
-      const errors = this.validateSchema.errors || [];
-      const errorMessages = errors.map(err => `${err.instancePath} ${err.message}`).join(', ');
-
-      throw new ValidationError(
-        `Schema validation failed: ${errorMessages}`,
-        'schema',
-        parsed,
-        projectConfigSchema
-      );
-    }
-
-    return parsed;
-  }
-}

package/src/llm/few-shot-examples.js

@@ -1,216 +0,0 @@
-/**
- * @fileoverview Few-shot examples for LLM prompt
- * @module morph-spec/llm/few-shot-examples
- */
-
-/**
- * Example 1: Next.js + Supabase stack
- */
-export const EXAMPLE_NEXTJS_SUPABASE = {
-  input: {
-    packageJson: {
-      name: 'my-nextjs-app',
-      dependencies: ['next', 'react', '@supabase/supabase-js', 'tailwindcss'],
-      devDependencies: ['typescript', 'eslint'],
-      scripts: { dev: 'next dev', build: 'next build' },
-      type: 'module'
-    },
-    csprojFilenames: [],
-    hasSolution: false,
-    readmeSummary: 'A modern web application built with Next.js 15 and Supabase...',
-    claudeMdSummary: null,
-    structure: {
-      hasSrc: true,
-      hasBackend: false,
-      hasFrontend: true,
-      hasTests: true,
-      topLevelDirs: ['src', 'app', 'components', 'lib', 'public', 'test'],
-      pattern: 'single-project'
-    },
-    infraSummary: {
-      dockerfilesCount: 1,
-      dockerComposeCount: 1,
-      bicepFilesCount: 0,
-      pipelinesCount: 0,
-      hasAzure: false,
-      hasDocker: true,
-      hasDevOps: false
-    },
-    gitRemoteDomain: 'github.com',
-    totalFiles: 60
-  },
-  output: {
-    name: 'my-nextjs-app',
-    description: 'A modern web application built with Next.js 15 and Supabase for backend',
-    type: 'nextjs',
-    stack: {
-      frontend: {
-        tech: 'Next.js',
-        version: '15',
-        details: 'App Router with Server Components'
-      },
-      backend: {
-        tech: 'Supabase',
-        version: 'latest',
-        details: 'PostgreSQL with real-time features'
-      },
-      database: {
-        tech: 'PostgreSQL',
-        version: '16',
-        details: 'Managed by Supabase'
-      },
-      hosting: 'Docker'
-    },
-    architecture: 'layered',
-    projectStructure: 'Next.js App Router: app/ for routes, components/ for UI, lib/ for utilities',
-    conventions: 'ESM modules, TypeScript, functional components with hooks',
-    repository: null,
-    hasAzure: false,
-    hasDocker: true,
-    hasDevOps: false,
-    confidence: 95,
-    warnings: []
-  }
-};
-
-/**
- * Example 2: Blazor Server + .NET + Azure SQL
- */
-export const EXAMPLE_BLAZOR_AZURE = {
-  input: {
-    packageJson: null,
-    csprojFilenames: ['MyApp.Web.csproj', 'MyApp.Domain.csproj', 'MyApp.Infrastructure.csproj'],
-    hasSolution: true,
-    readmeSummary: 'Enterprise web application built with Blazor Server and .NET 10...',
-    claudeMdSummary: 'Stack: Blazor Server + .NET 10 + Azure SQL. Architecture: Clean Architecture with DDD patterns...',
-    structure: {
-      hasSrc: true,
-      hasBackend: false,
-      hasFrontend: false,
-      hasTests: true,
-      topLevelDirs: ['src', 'test', 'infra', 'docs'],
-      pattern: 'single-project'
-    },
-    infraSummary: {
-      dockerfilesCount: 1,
-      dockerComposeCount: 0,
-      bicepFilesCount: 5,
-      pipelinesCount: 1,
-      hasAzure: true,
-      hasDocker: true,
-      hasDevOps: true
-    },
-    gitRemoteDomain: 'github.com',
-    totalFiles: 120
-  },
-  output: {
-    name: 'MyApp',
-    description: 'Enterprise web application built with Blazor Server and .NET 10, deployed to Azure',
-    type: 'blazor-server',
-    stack: {
-      frontend: {
-        tech: 'Blazor',
-        version: '10',
-        details: 'Blazor Server with SignalR'
-      },
-      backend: {
-        tech: '.NET',
-        version: '10',
-        details: 'Minimal API with Clean Architecture'
-      },
-      database: {
-        tech: 'Azure SQL',
-        version: 'latest',
-        details: 'Entity Framework Core'
-      },
-      hosting: 'Azure'
-    },
-    architecture: 'clean-architecture',
-    projectStructure: 'Clean Architecture: Domain (entities), Application (use cases), Infrastructure (EF Core), Web (Blazor UI)',
-    conventions: 'C# 14, nullable reference types, record types for DTOs, async/await, PascalCase',
-    repository: null,
-    hasAzure: true,
-    hasDocker: true,
-    hasDevOps: true,
-    confidence: 98,
-    warnings: []
-  }
-};
-
-/**
- * Example 3: Monorepo with Next.js + .NET API
- */
-export const EXAMPLE_MONOREPO = {
-  input: {
-    packageJson: {
-      name: 'monorepo-app',
-      dependencies: [],
-      devDependencies: ['turbo', 'lerna'],
-      scripts: { dev: 'turbo dev', build: 'turbo build' },
-      type: 'module'
-    },
-    csprojFilenames: ['backend/Api/Api.csproj', 'backend/Domain/Domain.csproj'],
-    hasSolution: true,
-    readmeSummary: 'Monorepo application with Next.js frontend and .NET backend API...',
-    claudeMdSummary: null,
-    structure: {
-      hasSrc: false,
-      hasBackend: true,
-      hasFrontend: true,
-      hasTests: true,
-      topLevelDirs: ['frontend', 'backend', 'packages', 'test'],
-      pattern: 'monorepo'
-    },
-    infraSummary: {
-      dockerfilesCount: 2,
-      dockerComposeCount: 1,
-      bicepFilesCount: 0,
-      pipelinesCount: 1,
-      hasAzure: false,
-      hasDocker: true,
-      hasDevOps: true
-    },
-    gitRemoteDomain: 'github.com',
-    totalFiles: 200
-  },
-  output: {
-    name: 'monorepo-app',
-    description: 'Monorepo application with Next.js frontend and .NET backend API',
-    type: 'monorepo',
-    stack: {
-      frontend: {
-        tech: 'Next.js',
-        version: 'latest',
-        details: 'App Router'
-      },
-      backend: {
-        tech: '.NET',
-        version: 'latest',
-        details: 'Minimal API'
-      },
-      database: null,
-      hosting: 'Docker'
-    },
-    architecture: 'microservices',
-    projectStructure: 'Monorepo: frontend/ (Next.js), backend/ (. NET API), packages/ (shared libs)',
-    conventions: 'Turbo for monorepo orchestration, ESM for frontend, C# for backend',
-    repository: null,
-    hasAzure: false,
-    hasDocker: true,
-    hasDevOps: true,
-    confidence: 90,
-    warnings: ['Database technology not detected - may not persist data']
-  }
-};
-
-/**
- * Get all few-shot examples
- * @returns {Array} Array of examples
- */
-export function getFewShotExamples() {
-  return [
-    EXAMPLE_NEXTJS_SUPABASE,
-    EXAMPLE_BLAZOR_AZURE,
-    EXAMPLE_MONOREPO
-  ];
-}

package/src/llm/project-config-schema.json

@@ -1,188 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "ProjectConfig",
-  "description": "Project configuration detected by LLM",
-  "type": "object",
-  "required": [
-    "name",
-    "description",
-    "type",
-    "stack",
-    "architecture",
-    "projectStructure",
-    "conventions",
-    "hasAzure",
-    "hasDocker",
-    "hasDevOps",
-    "confidence",
-    "warnings"
-  ],
-  "properties": {
-    "name": {
-      "type": "string",
-      "minLength": 1,
-      "description": "Project name (from package.json or repository)"
-    },
-    "description": {
-      "type": "string",
-      "minLength": 10,
-      "maxLength": 500,
-      "description": "Project description (1-2 sentences)"
-    },
-    "type": {
-      "type": "string",
-      "enum": [
-        "monorepo",
-        "blazor-server",
-        "nextjs",
-        "cli-tool",
-        "dotnet-api",
-        "other"
-      ],
-      "description": "Project type"
-    },
-    "stack": {
-      "type": "object",
-      "required": ["backend"],
-      "properties": {
-        "frontend": {
-          "oneOf": [
-            {
-              "type": "object",
-              "required": ["tech", "version"],
-              "properties": {
-                "tech": {
-                  "type": "string",
-                  "description": "Frontend technology (e.g., Next.js, Blazor)"
-                },
-                "version": {
-                  "type": "string",
-                  "description": "Version (e.g., 15, 10)"
-                },
-                "details": {
-                  "type": "string",
-                  "description": "Additional details (e.g., App Router, Server Components)"
-                }
-              }
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "backend": {
-          "type": "object",
-          "required": ["tech", "version"],
-          "properties": {
-            "tech": {
-              "type": "string",
-              "description": "Backend technology (e.g., .NET, Supabase, Node.js)"
-            },
-            "version": {
-              "type": "string",
-              "description": "Version (e.g., 10, 18, latest)"
-            },
-            "details": {
-              "type": "string",
-              "description": "Additional details (e.g., Minimal API, Express)"
-            }
-          }
-        },
-        "database": {
-          "oneOf": [
-            {
-              "type": "object",
-              "required": ["tech", "version"],
-              "properties": {
-                "tech": {
-                  "type": "string",
-                  "description": "Database technology (e.g., PostgreSQL, Azure SQL)"
-                },
-                "version": {
-                  "type": "string",
-                  "description": "Version"
-                },
-                "details": {
-                  "type": "string",
-                  "description": "Additional details"
-                }
-              }
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "hosting": {
-          "oneOf": [
-            {
-              "type": "string",
-              "description": "Hosting platform (e.g., Azure, Vercel, Docker)"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        }
-      }
-    },
-    "architecture": {
-      "type": "string",
-      "enum": [
-        "clean-architecture",
-        "monolith",
-        "microservices",
-        "layered",
-        "other"
-      ],
-      "description": "Architecture pattern"
-    },
-    "projectStructure": {
-      "type": "string",
-      "minLength": 10,
-      "description": "Description of folder structure"
-    },
-    "conventions": {
-      "type": "string",
-      "minLength": 5,
-      "description": "Detected code conventions"
-    },
-    "repository": {
-      "oneOf": [
-        {
-          "type": "string",
-          "format": "uri"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "description": "Git repository URL"
-    },
-    "hasAzure": {
-      "type": "boolean",
-      "description": "Uses Azure infrastructure"
-    },
-    "hasDocker": {
-      "type": "boolean",
-      "description": "Uses Docker containerization"
-    },
-    "hasDevOps": {
-      "type": "boolean",
-      "description": "Uses CI/CD pipelines"
-    },
-    "confidence": {
-      "type": "number",
-      "minimum": 0,
-      "maximum": 100,
-      "description": "LLM confidence score (0-100)"
-    },
-    "warnings": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "description": "Warnings or uncertainties detected"
-    }
-  }
-}