@livestore/cli 0.4.0 → 0.5.0-dev.1

package/src/commands/mcp-tools-defs.ts

@@ -1,4 +1,6 @@
-import { Schema, Tool, Toolkit } from '@livestore/utils/effect'
+import { Tool, Toolkit } from 'effect/ai'
+
+import { Schema } from '@livestore/utils/effect'
 
 import { coachTool } from './mcp-coach.ts'
 
@@ -8,32 +10,32 @@ export const livestoreToolkit = Toolkit.make(
   Tool.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({
+    parameters: Schema.Struct({
+      schemaType: Schema.String.annotate({
         description: "Schema type: 'todo', 'blog', 'social', 'ecommerce', or 'custom'",
       }),
       customDescription: Schema.optional(
-        Schema.String.annotations({
+        Schema.String.annotate({
           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' }),
+      schemaCode: Schema.String.annotate({ description: 'The generated LiveStore schema TypeScript code' }),
+      explanation: Schema.String.annotate({ description: 'Brief explanation of the schema structure' }),
     }),
   }),
 
   Tool.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'" }),
-    },
+    parameters: Schema.Struct({
+      type: Schema.String.annotate({ 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' }),
+      schemaCode: Schema.String.annotate({ description: 'The complete LiveStore schema code' }),
+      description: Schema.String.annotate({ description: 'Description of what this schema models' }),
     }),
   })
     .annotate(Tool.Readonly, true)
@@ -86,27 +88,27 @@ Returns on success:
     "eventNames": ["<event-name-1>", "<event-name-2>", "..."]
   }
 }`,
-    parameters: {
-      configPath: Schema.String.annotations({
+    parameters: Schema.Struct({
+      configPath: Schema.String.annotate({
         description: 'Path to a module that exports named variables: schema and syncBackend',
       }),
-      storeId: Schema.String.annotations({ description: 'Required store id for the LiveStore instance.' }),
+      storeId: Schema.String.annotate({ description: 'Required store id for the LiveStore instance.' }),
       clientId: Schema.optional(
-        Schema.String.annotations({ description: 'Optional client id for the LiveStore instance.' }),
+        Schema.String.annotate({ description: 'Optional client id for the LiveStore instance.' }),
       ),
       sessionId: Schema.optional(
-        Schema.String.annotations({ description: 'Optional session id for the LiveStore instance.' }),
+        Schema.String.annotate({ description: 'Optional session id for the LiveStore instance.' }),
       ),
-    },
+    }),
     success: Schema.Struct({
       storeId: Schema.String,
       clientId: Schema.String,
       sessionId: Schema.String,
       schemaInfo: Schema.Struct({
-        tableNames: Schema.Array(Schema.String).annotations({
+        tableNames: Schema.Array(Schema.String).annotate({
           description: 'Non-system table names in the connected schema',
         }),
-        eventNames: Schema.Array(Schema.String).annotations({
+        eventNames: Schema.Array(Schema.String).annotate({
           description: 'Canonical event names defined by the connected schema',
         }),
       }),
@@ -137,18 +139,18 @@ Returns on success:
   "rows": [{ "col": "value" }],
   "rowCount": 1
 }`,
-    parameters: {
-      sql: Schema.String.annotations({ description: 'The SQL query to execute' }),
-      bindValues: Schema.Union(
-        Schema.Array(Schema.JsonValue),
-        Schema.Record({ key: Schema.String, value: Schema.JsonValue }),
-      ).annotations({
+    parameters: Schema.Struct({
+      sql: Schema.String.annotate({ description: 'The SQL query to execute' }),
+      bindValues: Schema.Union([
+        Schema.Array(Schema.Json),
+        Schema.Record(Schema.String, Schema.Json),
+      ]).annotate({
         description: 'Bind values for the SQL query (array or record). Record keys must not start with $.',
       }),
-    },
+    }),
     success: Schema.Struct({
-      rows: Schema.Array(Schema.Record({ key: Schema.String, value: Schema.JsonValue })),
-      rowCount: Schema.Number,
+      rows: Schema.Array(Schema.Record(Schema.String, Schema.Json)),
+      rowCount: Schema.Finite,
     }),
   }).annotate(Tool.Destructive, false),
 
@@ -176,17 +178,17 @@ Example parameters:
 
 Returns on success:
 { "committed": 1 }`,
-    parameters: {
+    parameters: Schema.Struct({
       events: Schema.Array(
         Schema.Struct({
-          name: Schema.String.annotations({ description: 'The name of the event' }),
-          args: Schema.JsonValue.annotations({
+          name: Schema.String.annotate({ description: 'The name of the event' }),
+          args: Schema.Json.annotate({
             description: 'The arguments for the event as a non-stringified JSON value',
           }),
         }),
       ),
-    },
-    success: Schema.Struct({ committed: Schema.Number }),
+    }),
+    success: Schema.Struct({ committed: Schema.Finite }),
   }).annotate(Tool.Destructive, true),
 
   Tool.make('livestore_instance_status', {
@@ -205,18 +207,18 @@ Returns when not connected:
 {
   "_tag": "disconnected"
 }`,
-    parameters: {},
-    success: Schema.Union(
+    parameters: Tool.EmptyParams,
+    success: Schema.Union([
       Schema.TaggedStruct('connected', {
         storeId: Schema.String,
         clientId: Schema.String,
         sessionId: Schema.String,
-        tableCounts: Schema.Record({ key: Schema.String, value: Schema.Number }).annotations({
+        tableCounts: Schema.Record(Schema.String, Schema.Finite).annotate({
           description: 'Tables in the LiveStore instance with their row count',
         }),
       }),
       Schema.TaggedStruct('disconnected', {}),
-    ),
+    ]),
   }).annotate(Tool.Readonly, true),
 
   Tool.make('livestore_instance_disconnect', {
@@ -224,7 +226,7 @@ Returns when not connected:
 
 Example success:
 { "_tag": "disconnected" }`,
-    parameters: {},
+    parameters: Tool.EmptyParams,
     success: Schema.TaggedStruct('disconnected', {}),
   }),
 
@@ -253,18 +255,18 @@ Returns on success:
   "exportedAt": "2024-01-15T10:30:00.000Z",
   "data": { "version": 1, "storeId": "my-store", ... }
 }`,
-    parameters: {
-      configPath: Schema.String.annotations({
+    parameters: Schema.Struct({
+      configPath: Schema.String.annotate({
         description: 'Path to a module that exports schema and syncBackend',
       }),
-      storeId: Schema.String.annotations({ description: 'Store identifier' }),
-      clientId: Schema.optional(Schema.String.annotations({ description: 'Client identifier (default: mcp-export)' })),
-    },
+      storeId: Schema.String.annotate({ description: 'Store identifier' }),
+      clientId: Schema.optional(Schema.String.annotate({ description: 'Client identifier (default: mcp-export)' })),
+    }),
     success: Schema.Struct({
       storeId: Schema.String,
-      eventCount: Schema.Number,
+      eventCount: Schema.Finite,
       exportedAt: Schema.String,
-      data: Schema.JsonValue.annotations({ description: 'The export file data (can be saved or passed to import)' }),
+      data: Schema.Json.annotate({ description: 'The export file data (can be saved or passed to import)' }),
     }),
   }).annotate(Tool.Readonly, true),
 
@@ -295,23 +297,23 @@ Returns on success:
   "eventCount": 127,
   "dryRun": false
 }`,
-    parameters: {
-      configPath: Schema.String.annotations({
+    parameters: Schema.Struct({
+      configPath: Schema.String.annotate({
         description: 'Path to a module that exports schema and syncBackend',
       }),
-      storeId: Schema.String.annotations({ description: 'Store identifier' }),
-      clientId: Schema.optional(Schema.String.annotations({ description: 'Client identifier (default: mcp-import)' })),
-      data: Schema.JsonValue.annotations({
+      storeId: Schema.String.annotate({ description: 'Store identifier' }),
+      clientId: Schema.optional(Schema.String.annotate({ description: 'Client identifier (default: mcp-import)' })),
+      data: Schema.Json.annotate({
         description: 'The export data to import (from livestore_sync_export or a file)',
       }),
       force: Schema.optional(
-        Schema.Boolean.annotations({ description: 'Force import even if store ID does not match' }),
+        Schema.Boolean.annotate({ description: 'Force import even if store ID does not match' }),
       ),
-      dryRun: Schema.optional(Schema.Boolean.annotations({ description: 'Validate without actually importing' })),
-    },
+      dryRun: Schema.optional(Schema.Boolean.annotate({ description: 'Validate without actually importing' })),
+    }),
     success: Schema.Struct({
       storeId: Schema.String,
-      eventCount: Schema.Number,
+      eventCount: Schema.Finite,
       dryRun: Schema.Boolean,
     }),
   }).annotate(Tool.Destructive, true),

package/src/commands/mcp.ts

@@ -1,4 +1,6 @@
-import { Effect, Layer, Logger, McpServer } from '@livestore/utils/effect'
+import { McpProtocol, McpServer } from 'effect/ai'
+
+import { Effect, Layer, Logger } from '@livestore/utils/effect'
 import { Cli, PlatformNode } from '@livestore/utils/node'
 
 import { architectureContent } from '../mcp-content/architecture.ts'
@@ -11,6 +13,7 @@ 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 { toolHandlers } from './mcp-tool-handlers.ts'
+import { supportedMcpProtocols } from './mcp-protocols.ts'
 // Tools imports
 import { livestoreToolkit } from './mcp-tools-defs.ts'
 
@@ -84,12 +87,14 @@ const mcpServerCommand = Cli.Command.make(
     return yield* McpServer.layerStdio({
       name: 'livestore-mcp',
       version: '0.1.0',
-      stdin: PlatformNode.NodeStream.stdin,
-      stdout: PlatformNode.NodeSink.stdout,
+      protocols: supportedMcpProtocols,
     }).pipe(
       Layer.provide(LivestoreResources),
       Layer.provide(LivestoreTools),
-      Layer.provide(Logger.add(Logger.prettyLogger({ stderr: true }))),
+      Layer.provide(
+        Layer.merge(Logger.layer([Logger.consolePretty()]), Layer.succeed(Logger.LogToStderr, true)),
+      ),
+      Layer.provide(PlatformNode.NodeStdio.layer),
       Layer.launch,
     )
   }),

package/src/commands/new-project.ts

@@ -3,7 +3,8 @@ import * as nodePath from 'node:path'
 
 import { sluggify } from '@livestore/utils'
 import {
-  Command,
+  ChildProcess,
+  ChildProcessSpawner,
   Console,
   Effect,
   FileSystem,
@@ -19,7 +20,7 @@ import { detectPackageManager, pmCommands } from '../package-manager.ts'
 // Schema for GitHub API response
 const GitHubContentSchema = Schema.Struct({
   name: Schema.String,
-  type: Schema.Literal('dir', 'file'),
+  type: Schema.Literals(['dir', 'file']),
   path: Schema.String,
   download_url: Schema.NullOr(Schema.String),
 })
@@ -34,11 +35,13 @@ const githubRequest = (url: string) => {
 
 /** Schema for parsing package.json scripts (dev or start) */
 const PackageJsonScriptsSchema = Schema.Struct({
-  scripts: Schema.Union(Schema.Struct({ dev: Schema.String }), Schema.Struct({ start: Schema.String })),
+  scripts: Schema.Union([Schema.Struct({ dev: Schema.String }), Schema.Struct({ start: Schema.String })]),
 })
 
 // Error types
-export class ExampleNotFoundError extends Schema.TaggedError<ExampleNotFoundError>('~@livestore/cli/ExampleNotFoundError')('ExampleNotFoundError', {
+export class ExampleNotFoundError extends Schema.TaggedError<ExampleNotFoundError>(
+  '~@livestore/cli/ExampleNotFoundError',
+)('ExampleNotFoundError', {
   exampleName: Schema.String,
   availableExamples: Schema.Array(Schema.String),
   message: Schema.String,
@@ -49,14 +52,19 @@ export class NetworkError extends Schema.TaggedError<NetworkError>('~@livestore/
   message: Schema.String,
 }) {}
 
-export class DirectoryExistsError extends Schema.TaggedError<DirectoryExistsError>('~@livestore/cli/DirectoryExistsError')('DirectoryExistsError', {
+export class DirectoryExistsError extends Schema.TaggedError<DirectoryExistsError>(
+  '~@livestore/cli/DirectoryExistsError',
+)('DirectoryExistsError', {
   path: Schema.String,
   message: Schema.String,
 }) {}
 
-export class NoExamplesError extends Schema.TaggedError<NoExamplesError>('~@livestore/cli/NoExamplesError')('NoExamplesError', {
-  message: Schema.String,
-}) {}
+export class NoExamplesError extends Schema.TaggedError<NoExamplesError>('~@livestore/cli/NoExamplesError')(
+  'NoExamplesError',
+  {
+    message: Schema.String,
+  },
+) {}
 
 // Fetch available examples from GitHub
 const fetchExamples = (ref: string) =>
@@ -68,7 +76,7 @@ const fetchExamples = (ref: string) =>
     const request = githubRequest(url)
     const response = yield* HttpClient.execute(request).pipe(
       Effect.scoped,
-      Effect.catchAll(
+      Effect.catch(
         (error) =>
           new NetworkError({
             cause: error,
@@ -79,8 +87,10 @@ const fetchExamples = (ref: string) =>
 
     const responseText = yield* response.text
 
-    const examples = yield* Schema.decodeUnknown(Schema.parseJson(GitHubContentsResponseSchema))(responseText).pipe(
-      Effect.catchAll(
+    const examples = yield* Schema.decodeEffect(Schema.fromJsonString(GitHubContentsResponseSchema))(
+      responseText,
+    ).pipe(
+      Effect.catch(
         (error) =>
           new NetworkError({
             cause: error,
@@ -106,7 +116,7 @@ const selectExample = (examples: string[]) =>
       return yield* new NoExamplesError({ message: 'No examples available' })
     }
 
-    const prompt = Cli.Prompt.select({
+    const prompt = Cli.Prompt.Select({
       message: '📦 Select a LiveStore example to create:',
       choices: examples.map((example) => ({
         title: example,
@@ -123,6 +133,8 @@ const downloadExample = (exampleName: string, ref: string, destinationPath: stri
   Effect.gen(function* () {
     yield* Console.log(`📥 Downloading example "${exampleName}" from ref "${ref}"...`)
 
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+
     const tempDir = yield* Effect.sync(() => os.tmpdir())
     const tarballPath = nodePath.join(tempDir, `livestore-${sluggify(ref)}-${Date.now()}.tar.gz`)
     const tarballUrl = `https://api.github.com/repos/livestorejs/livestore/tarball/${ref}`
@@ -132,7 +144,7 @@ const downloadExample = (exampleName: string, ref: string, destinationPath: stri
 
     const response = yield* HttpClient.execute(request).pipe(
       Effect.scoped,
-      Effect.catchAll(
+      Effect.catch(
         (error) =>
           new NetworkError({
             cause: error,
@@ -154,10 +166,9 @@ const downloadExample = (exampleName: string, ref: string, destinationPath: stri
     const extractDir = nodePath.join(tempDir, `extract-${Date.now()}`)
     yield* fs.makeDirectory(extractDir, { recursive: true })
 
-    // Extract tarball using Effect Command
-    yield* Command.make('tar', '-xzf', tarballPath, '-C', extractDir).pipe(
-      Command.exitCode,
-      Effect.catchAll(
+    // Extract tarball using a child process
+    yield* spawner.exitCode(ChildProcess.make('tar', ['-xzf', tarballPath, '-C', extractDir])).pipe(
+      Effect.catch(
         (error) =>
           new NetworkError({
             cause: error,
@@ -190,10 +201,9 @@ const downloadExample = (exampleName: string, ref: string, destinationPath: stri
       })
     }
 
-    // Copy the example directory contents to the destination using Effect Command
-    yield* Command.make('cp', '-r', `${exampleSourcePath}/.`, destinationPath).pipe(
-      Command.exitCode,
-      Effect.catchAll(
+    // Copy the example directory contents to the destination using a child process
+    yield* spawner.exitCode(ChildProcess.make('cp', ['-r', `${exampleSourcePath}/.`, destinationPath])).pipe(
+      Effect.catch(
         (error) =>
           new NetworkError({
             cause: error,
@@ -203,10 +213,10 @@ const downloadExample = (exampleName: string, ref: string, destinationPath: stri
     )
 
     // Clean up extract directory
-    yield* fs.remove(extractDir, { recursive: true }).pipe(Effect.catchAll(() => Effect.void))
+    yield* fs.remove(extractDir, { recursive: true }).pipe(Effect.ignore)
 
     // Clean up tarball
-    yield* fs.remove(tarballPath).pipe(Effect.catchAll(() => Effect.void))
+    yield* fs.remove(tarballPath).pipe(Effect.ignore)
 
     yield* Console.log(`✅ Example "${exampleName}" created successfully at: ${destinationPath}`)
   })
@@ -214,22 +224,22 @@ const downloadExample = (exampleName: string, ref: string, destinationPath: stri
 export const createCommand = Cli.Command.make(
   'create',
   {
-    example: Cli.Options.text('example').pipe(
-      Cli.Options.optional,
-      Cli.Options.withDescription('Example name to create (bypasses interactive selection)'),
+    example: Cli.Flag.String('example').pipe(
+      Cli.Flag.optional,
+      Cli.Flag.withDescription('Example name to create (bypasses interactive selection)'),
     ),
-    ref: Cli.Options.text('ref').pipe(
-      Cli.Options.withAlias('commit'),
-      Cli.Options.withAlias('branch'),
-      Cli.Options.withAlias('tag'),
-      Cli.Options.withDefault('main'),
-      Cli.Options.withDescription(
+    ref: Cli.Flag.String('ref').pipe(
+      Cli.Flag.withAlias('commit'),
+      Cli.Flag.withAlias('branch'),
+      Cli.Flag.withAlias('tag'),
+      Cli.Flag.withDefault('main'),
+      Cli.Flag.withDescription(
         'The name of the commit/branch/tag to fetch examples from. Pull requests refs must be fully-formed (e.g., `refs/pull/123/merge`).',
       ),
     ),
-    path: Cli.Args.text({ name: 'path' }).pipe(
-      Cli.Args.optional,
-      Cli.Args.withDescription('Destination path for the new project'),
+    path: Cli.Argument.String('path').pipe(
+      Cli.Argument.optional,
+      Cli.Argument.withDescription('Destination path for the new project'),
     ),
   },
   Effect.fn(function* ({
@@ -270,7 +280,8 @@ export const createCommand = Cli.Command.make(
     }
 
     // Determine destination path
-    const destinationPath = Option.isSome(path) === true ? nodePath.resolve(path.value) : nodePath.resolve(selectedExample)
+    const destinationPath =
+      Option.isSome(path) === true ? nodePath.resolve(path.value) : nodePath.resolve(selectedExample)
 
     // Download and extract the example
     yield* downloadExample(selectedExample, ref, destinationPath)
@@ -281,7 +292,9 @@ export const createCommand = Cli.Command.make(
     const fs = yield* FileSystem.FileSystem
     const packageJsonPath = nodePath.join(destinationPath, 'package.json')
     const packageJsonContent = yield* fs.readFileString(packageJsonPath)
-    const runScript = yield* Schema.decodeUnknown(Schema.parseJson(PackageJsonScriptsSchema))(packageJsonContent).pipe(
+    const runScript = yield* Schema.decodeEffect(Schema.fromJsonString(PackageJsonScriptsSchema))(
+      packageJsonContent,
+    ).pipe(
       Effect.map((pkg) => ('dev' in pkg.scripts ? ('dev' as const) : ('start' as const))),
       Effect.orElseSucceed(() => undefined),
     )

package/src/mcp-content/architecture.ts

@@ -28,9 +28,9 @@ LiveStore implements distributed systems principles from Martin Kleppmann's rese
 \`\`\`typescript
 // Materialized views from event log
 const materializers = State.SQLite.materializers(events, {
-  'TodoCreated': ({ id, text, createdAt }) => 
+  'TodoCreated': ({ id, text, createdAt }) =>
     tables.todos.insert({ id, text, completed: false, createdAt }),
-  'TodoCompleted': ({ id }) => 
+  'TodoCompleted': ({ id }) =>
     tables.todos.update({ completed: true }).where({ id })
 })
 \`\`\`
@@ -46,7 +46,7 @@ const materializers = State.SQLite.materializers(events, {
 const events = {
   todoCompleted: Events.synced({
     name: 'v1.TodoCompleted',
-    schema: Schema.Struct({ 
+    schema: Schema.Struct({
       id: Schema.String,
       completedAt: Schema.Date // For conflict resolution
     })

package/src/mcp-content/features.ts

@@ -149,7 +149,7 @@ await testStore.replay([
 
 ### Developer Tools
 - **Event Inspector**: Real-time event log visualization
-- **Query Profiler**: Performance analysis for slow queries  
+- **Query Profiler**: Performance analysis for slow queries
 - **Sync Monitor**: Network synchronization health dashboard
 - **Schema Explorer**: Interactive database schema browsing