@livestore/cli 0.0.0-snapshot-2ac5fd340c97c9e07fe4c5dc6d31d5132aa6557c.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@livestore/cli",
+  "version": "0.0.0-snapshot-2ac5fd340c97c9e07fe4c5dc6d31d5132aa6557c.0",
+  "type": "module",
+  "exports": {
+    ".": "./dist/mod.js"
+  },
+  "bin": {
+    "livestore": "./dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@effect/ai-openai": "^0.29.0",
+    "@livestore/utils-dev": "0.0.0-snapshot-2ac5fd340c97c9e07fe4c5dc6d31d5132aa6557c.0",
+    "@livestore/utils": "0.0.0-snapshot-2ac5fd340c97c9e07fe4c5dc6d31d5132aa6557c.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.2.0",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "bun src/cli.ts"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { Effect, FetchHttpClient, Layer, Logger, LogLevel } from '@livestore/utils/effect'
+import { Cli, PlatformNode } from '@livestore/utils/node'
+import { mcpCommand } from './commands/mcp.ts'
+import { newProjectCommand } from './commands/new-project.ts'
+
+const helloCommand = Cli.Command.make(
+  'hello',
+  {
+    name: Cli.Options.text('name').pipe(Cli.Options.withDefault('World')),
+  },
+  Effect.fn(function* ({ name }: { name: string }) {
+    yield* Effect.log(`Hello, ${name}! 🎉`)
+  }),
+)
+
+export const command = Cli.Command.make('livestore', {
+  verbose: Cli.Options.boolean('verbose').pipe(Cli.Options.withDefault(false)),
+}).pipe(Cli.Command.withSubcommands([helloCommand, mcpCommand, newProjectCommand]))
+
+if (import.meta.main) {
+  const cli = Cli.Command.run(command, {
+    name: 'livestore',
+    version: '0.1.0',
+  })
+
+  const layer = Layer.mergeAll(
+    PlatformNode.NodeContext.layer,
+    FetchHttpClient.layer,
+    Logger.minimumLogLevel(LogLevel.Info),
+  )
+
+  cli(process.argv).pipe(Effect.provide(layer), PlatformNode.NodeRuntime.runMain)
+}

package/src/commands/mcp-coach.ts

@@ -0,0 +1,121 @@
+import { OpenAiClient, OpenAiLanguageModel } from '@effect/ai-openai'
+import {
+  AiError,
+  AiLanguageModel,
+  AiTool,
+  Config,
+  Effect,
+  FetchHttpClient,
+  Layer,
+  Schema,
+} from '@livestore/utils/effect'
+
+// Define the coach tool that analyzes LiveStore usage
+export const coachTool = AiTool.make('livestore_coach', {
+  description:
+    'Analyze LiveStore code (schemas, queries, mutations, etc.) and provide AI-powered feedback on best practices, performance, and improvements.',
+  parameters: {
+    code: Schema.String.annotations({
+      description: 'The LiveStore code to analyze (TypeScript/JavaScript)',
+    }),
+    codeType: Schema.optional(
+      Schema.String.annotations({
+        description: "Type of code being analyzed: 'schema', 'query', 'mutation', 'component', or 'general'",
+      }),
+    ),
+  },
+  success: Schema.Struct({
+    feedback: Schema.String.annotations({
+      description: 'AI-generated feedback and recommendations for the code',
+    }),
+    score: Schema.optional(
+      Schema.Number.annotations({
+        description: 'Code quality score from 1-10 (optional)',
+      }),
+    ),
+    suggestions: Schema.Array(
+      Schema.String.annotations({
+        description: 'Specific actionable suggestions for improvement',
+      }),
+    ).annotations({
+      description: 'List of specific improvement suggestions',
+    }),
+  }),
+  failure: AiError.AiError,
+})
+
+const OpenAiClientLayer = OpenAiClient.layerConfig({
+  apiKey: Config.redacted('OPENAI_API_KEY'),
+})
+
+const OpenAiModel = OpenAiLanguageModel.layer({
+  model: 'gpt-5-nano',
+})
+
+// Coach tool handler that uses OpenAI for analysis
+export const coachToolHandler = Effect.fnUntraced(
+  function* ({ code, codeType }) {
+    // Build the analysis prompt
+    const codeTypeContext = codeType ? `This is ${codeType} code using LiveStore. ` : 'This is LiveStore code. '
+
+    const prompt = `${codeTypeContext}Please review the following code and provide helpful feedback focusing on:
+
+1. LiveStore best practices and conventions
+2. Schema design and relationships (if applicable)
+3. Query optimization and performance
+4. Code structure and maintainability
+5. Security considerations
+6. Naming conventions
+7. TypeScript usage and type safety
+
+Code to review:
+\`\`\`typescript
+${code}
+\`\`\`
+
+Please provide:
+1. Overall assessment and quality score (1-10)
+2. Specific areas for improvement
+3. Best practice recommendations
+4. Any potential issues or concerns
+
+Format your response as constructive feedback that helps developers improve their LiveStore usage.`
+
+    const systemPrompt = `You are an expert LiveStore developer and code reviewer. Provide constructive, specific, and actionable feedback on LiveStore code. Focus on best practices, performance, and maintainability.`
+
+    // Get OpenAI client and call the API
+    const llm = yield* AiLanguageModel.AiLanguageModel
+    const completion = yield* llm.generateText({ prompt, system: systemPrompt })
+
+    const feedback = completion.text ?? 'Unable to generate feedback'
+
+    // Extract suggestions from the feedback (simple approach)
+    const suggestions: string[] = feedback
+      .split('\n')
+      .filter(
+        (line: string) =>
+          line.trim().startsWith('-') ||
+          line.trim().startsWith('*') ||
+          line.trim().startsWith('•') ||
+          line.toLowerCase().includes('recommend') ||
+          line.toLowerCase().includes('consider') ||
+          line.toLowerCase().includes('improve'),
+      )
+      .map((line: string) => line.replace(/^[-*•]\s*/, '').trim())
+      .filter((suggestion: string) => suggestion.length > 10)
+      .slice(0, 5) // Limit to 5 suggestions
+
+    // Try to extract a score (simple regex approach)
+    const scoreMatch = feedback.match(/(?:score|rating|quality).*?(\d+(?:\.\d+)?)/i)
+    const score = scoreMatch ? Number.parseFloat(scoreMatch[1] ?? '0') : undefined
+
+    return {
+      feedback,
+      score: score && score >= 1 && score <= 10 ? score : undefined,
+      suggestions,
+    }
+  },
+  Effect.provide(Layer.provideMerge(OpenAiModel, OpenAiClientLayer)),
+  Effect.provide(FetchHttpClient.layer),
+  Effect.catchTag('ConfigError', (e) => Effect.die(e)),
+)

package/src/commands/mcp-tools.ts

@@ -0,0 +1,169 @@
+import { AiTool, AiToolkit, Effect, Schema } from '@livestore/utils/effect'
+import { blogSchemaContent } from '../mcp-content/schemas/blog.ts'
+import { ecommerceSchemaContent } from '../mcp-content/schemas/ecommerce.ts'
+import { socialSchemaContent } from '../mcp-content/schemas/social.ts'
+import { todoSchemaContent } from '../mcp-content/schemas/todo.ts'
+import { coachTool, coachToolHandler } from './mcp-coach.ts'
+
+// Create toolkit with tools and handlers following Tim Smart's pattern
+export const livestoreToolkit = AiToolkit.make(
+  coachTool,
+
+  AiTool.make('livestore_generate_schema', {
+    description:
+      'Generate a LiveStore schema for a specific use case. Choose from predefined types (todo, blog, social, ecommerce) or request a custom schema by providing a description.',
+    parameters: {
+      schemaType: Schema.String.annotations({
+        description: "Schema type: 'todo', 'blog', 'social', 'ecommerce', or 'custom'",
+      }),
+      customDescription: Schema.optional(
+        Schema.String.annotations({
+          description:
+            "For custom schemas: describe your data model needs (e.g., 'user management system with roles and permissions')",
+        }),
+      ),
+    },
+    success: Schema.Struct({
+      schemaCode: Schema.String.annotations({
+        description: 'The generated LiveStore schema TypeScript code',
+      }),
+      explanation: Schema.String.annotations({
+        description: 'Brief explanation of the schema structure',
+      }),
+    }),
+  }),
+
+  AiTool.make('livestore_get_example_schema', {
+    description:
+      'Get a complete example LiveStore schema with TypeScript code. Returns ready-to-use schema definitions for common application types.',
+    parameters: {
+      type: Schema.String.annotations({
+        description: "Example type: 'todo', 'blog', 'social', or 'ecommerce'",
+      }),
+    },
+    success: Schema.Struct({
+      schemaCode: Schema.String.annotations({
+        description: 'The complete LiveStore schema code',
+      }),
+      description: Schema.String.annotations({
+        description: 'Description of what this schema models',
+      }),
+    }),
+  })
+    .annotate(AiTool.Readonly, true)
+    .annotate(AiTool.Destructive, false),
+)
+
+// Tool handlers using Tim Smart's pattern
+export const toolHandlers = livestoreToolkit.of({
+  livestore_coach: coachToolHandler,
+
+  livestore_generate_schema: Effect.fnUntraced(function* ({ schemaType, customDescription }) {
+    let schemaCode: string
+    let explanation: string
+
+    switch (schemaType.toLowerCase()) {
+      case 'todo':
+        schemaCode = todoSchemaContent
+        explanation = 'Todo application schema with tasks, tags, and many-to-many relationships'
+        break
+      case 'blog':
+        schemaCode = blogSchemaContent
+        explanation = 'Blog platform schema with posts, comments, and publishing workflow'
+        break
+      case 'social':
+        schemaCode = socialSchemaContent
+        explanation = 'Social media schema with users, posts, follows, and likes'
+        break
+      case 'ecommerce':
+        schemaCode = ecommerceSchemaContent
+        explanation = 'E-commerce schema with products, categories, orders, and inventory'
+        break
+      case 'custom': {
+        if (!customDescription) {
+          schemaCode = `// Custom schema requested but no description provided
+import { Schema } from '@livestore/livestore'
+
+// Please provide a description of your data model needs
+export const CustomSchema = Schema.table('items', {
+  id: Schema.id,
+  name: Schema.text,
+  createdAt: Schema.datetime.default('now')
+})
+
+export const schema = Schema.create({
+  items: CustomSchema
+})`
+          explanation = 'Basic custom schema template - please provide more details about your requirements'
+          break
+        }
+
+        // Generate a basic custom schema based on description
+        const tableName = customDescription.toLowerCase().includes('user')
+          ? 'users'
+          : customDescription.toLowerCase().includes('product')
+            ? 'products'
+            : customDescription.toLowerCase().includes('post')
+              ? 'posts'
+              : 'items'
+
+        schemaCode = `// Custom schema based on: ${customDescription}
+import { Schema } from '@livestore/livestore'
+
+export const ${tableName.charAt(0).toUpperCase() + tableName.slice(0, -1)}Schema = Schema.table('${tableName}', {
+  id: Schema.id,
+  name: Schema.text,
+  description: Schema.text.optional(),
+  createdAt: Schema.datetime.default('now'),
+  updatedAt: Schema.datetime.default('now')
+})
+
+export const schema = Schema.create({
+  ${tableName}: ${tableName.charAt(0).toUpperCase() + tableName.slice(0, -1)}Schema
+})`
+
+        explanation = `Custom schema generated for: ${customDescription}. This is a basic template - you may need to customize the fields based on your specific requirements.`
+        break
+      }
+      default:
+        schemaCode = todoSchemaContent
+        explanation =
+          'Unknown schema type, returning todo example. Available types: todo, blog, social, ecommerce, custom'
+    }
+
+    return { schemaCode, explanation }
+  }),
+
+  livestore_get_example_schema: Effect.fnUntraced(function* ({ type }) {
+    let schemaCode: string
+    let description: string
+
+    switch (type.toLowerCase()) {
+      case 'todo':
+        schemaCode = todoSchemaContent
+        description =
+          'Complete todo application with tasks, tags, and many-to-many relationships. Includes boolean completion status and timestamps.'
+        break
+      case 'blog':
+        schemaCode = blogSchemaContent
+        description =
+          'Blog platform with posts and comments. Features published status, unique slugs, and author attribution.'
+        break
+      case 'social':
+        schemaCode = socialSchemaContent
+        description =
+          'Social media platform with users, posts, follows, and likes. Includes user profiles and social interactions.'
+        break
+      case 'ecommerce':
+        schemaCode = ecommerceSchemaContent
+        description =
+          'E-commerce platform with products, categories, orders, and inventory management. Features order items and status tracking.'
+        break
+      default:
+        schemaCode = todoSchemaContent
+        description = 'Default todo example (unknown type requested). Available types: todo, blog, social, ecommerce'
+    }
+
+    return { schemaCode, description }
+  }),
+})

package/src/commands/mcp.ts

@@ -0,0 +1,97 @@
+import { Effect, Layer, Logger, McpServer } from '@livestore/utils/effect'
+import { Cli, PlatformNode } from '@livestore/utils/node'
+import { architectureContent } from '../mcp-content/architecture.ts'
+import { featuresContent } from '../mcp-content/features.ts'
+import { gettingStartedContent } from '../mcp-content/getting-started.ts'
+// Content imports
+import { overviewContent } from '../mcp-content/overview.ts'
+import { blogSchemaContent } from '../mcp-content/schemas/blog.ts'
+import { ecommerceSchemaContent } from '../mcp-content/schemas/ecommerce.ts'
+import { socialSchemaContent } from '../mcp-content/schemas/social.ts'
+import { todoSchemaContent } from '../mcp-content/schemas/todo.ts'
+
+// Tools imports
+import { livestoreToolkit, toolHandlers } from './mcp-tools.ts'
+
+const LivestoreResources = Layer.mergeAll(
+  McpServer.resource({
+    uri: 'livestore://overview',
+    name: 'LiveStore Overview',
+    description: 'Overview of LiveStore - the local-first data platform',
+    content: Effect.succeed(overviewContent),
+  }),
+
+  McpServer.resource({
+    uri: 'livestore://features',
+    name: 'LiveStore Features',
+    description: 'Core features and capabilities of LiveStore',
+    content: Effect.succeed(featuresContent),
+  }),
+
+  McpServer.resource({
+    uri: 'livestore://getting-started',
+    name: 'Getting Started with LiveStore',
+    description: 'Quick start guide for LiveStore development',
+    content: Effect.succeed(gettingStartedContent),
+  }),
+
+  McpServer.resource({
+    uri: 'livestore://architecture',
+    name: 'LiveStore Architecture',
+    description: 'Technical architecture and design principles of LiveStore',
+    content: Effect.succeed(architectureContent),
+  }),
+
+  McpServer.resource({
+    uri: 'livestore://schemas/todo',
+    name: 'Todo App Schema',
+    description: 'Complete LiveStore schema for a todo application with tags',
+    content: Effect.succeed(todoSchemaContent),
+  }),
+
+  McpServer.resource({
+    uri: 'livestore://schemas/blog',
+    name: 'Blog Platform Schema',
+    description: 'LiveStore schema for a blog platform with posts and comments',
+    content: Effect.succeed(blogSchemaContent),
+  }),
+
+  McpServer.resource({
+    uri: 'livestore://schemas/social',
+    name: 'Social Media Schema',
+    description: 'LiveStore schema for a social media platform with users, posts, and interactions',
+    content: Effect.succeed(socialSchemaContent),
+  }),
+
+  McpServer.resource({
+    uri: 'livestore://schemas/ecommerce',
+    name: 'E-commerce Schema',
+    description: 'LiveStore schema for an e-commerce platform with products, orders, and categories',
+    content: Effect.succeed(ecommerceSchemaContent),
+  }),
+)
+
+const LivestoreTools = McpServer.toolkit(livestoreToolkit).pipe(Layer.provide(livestoreToolkit.toLayer(toolHandlers)))
+
+const mcpServerCommand = Cli.Command.make(
+  'server',
+  {},
+  Effect.fn(function* () {
+    yield* Effect.log('🚀 Starting LiveStore MCP Server...')
+
+    // Following Tim Smart's exact pattern from main.ts
+    return yield* McpServer.layerStdio({
+      name: 'livestore-mcp',
+      version: '0.1.0',
+      stdin: PlatformNode.NodeStream.stdin,
+      stdout: PlatformNode.NodeSink.stdout,
+    }).pipe(
+      Layer.provide(LivestoreResources),
+      Layer.provide(LivestoreTools),
+      Layer.provide(Logger.add(Logger.prettyLogger({ stderr: true }))),
+      Layer.launch,
+    )
+  }),
+)
+
+export const mcpCommand = Cli.Command.make('mcp').pipe(Cli.Command.withSubcommands([mcpServerCommand]))