@livestore/cli 0.4.0-dev.9 → 0.4.0

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

@@ -0,0 +1,318 @@
+import { Schema, Tool, Toolkit } from '@livestore/utils/effect'
+
+import { coachTool } from './mcp-coach.ts'
+
+export const livestoreToolkit = Toolkit.make(
+  coachTool,
+
+  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({
+        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' }),
+    }),
+  }),
+
+  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'" }),
+    },
+    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(Tool.Readonly, true)
+    .annotate(Tool.Destructive, false),
+
+  Tool.make('livestore_instance_connect', {
+    description: `Connect a LiveStore instance (one active per MCP session) by dynamically importing a user module that exports a LiveStore \`schema\` and a \`syncBackend\` factory (and optionally \`syncPayload\`).
+Notes:
+- Only one instance can be active at a time; calling connect again shuts down and replaces the previous instance.
+- Reconnecting creates a fresh, in-memory client database. The state visible to queries is populated by your backend's initial sync behavior; depending on configuration, you may briefly observe empty or partial data until sync completes.
+- \`configPath\` is resolved relative to the current working directory.
+- \`syncBackend\` must be a function (factory) that returns a backend; \`syncPayload\` must be JSON-serializable.
+
+Module contract (generic example):
+\`\`\`ts
+// Choose any supported sync provider for your deployment
+import { makeWsSync } from '@livestore/sync-cf/client' // or your own provider
+
+// Export your app's schema
+export { schema } from './src/livestore/schema.ts'
+
+// Provide a sync backend (e.g., WebSocket). Configure via env in practice.
+export const syncBackend = makeWsSync({ url: process.env.LIVESTORE_SYNC_URL ?? 'ws://localhost:8787' })
+
+// Optionally, pass an auth payload for your backend (must be JSON-serializable)
+export const syncPayload = { authToken: process.env.LIVESTORE_SYNC_AUTH_TOKEN ?? 'insecure-token-change-me' }
+\`\`\`
+
+Connect parameters:
+{
+  "configPath": "livestore-cli.config.ts",
+  "storeId": "<store-id>"
+}
+
+Optional identifiers to group client state on the server:
+{
+  "configPath": "livestore-cli.config.ts",
+  "storeId": "<store-id>",
+  "clientId": "<client-id>",
+  "sessionId": "<session-id>"
+}
+
+Returns on success:
+{
+  "storeId": "<store-id>",
+  "clientId": "<client-id>",
+  "sessionId": "<session-id>",
+  "schemaInfo": {
+    "tableNames": ["<table-1>", "<table-2>", "..."],
+    "eventNames": ["<event-name-1>", "<event-name-2>", "..."]
+  }
+}`,
+    parameters: {
+      configPath: Schema.String.annotations({
+        description: 'Path to a module that exports named variables: schema and syncBackend',
+      }),
+      storeId: Schema.String.annotations({ description: 'Required store id for the LiveStore instance.' }),
+      clientId: Schema.optional(
+        Schema.String.annotations({ description: 'Optional client id for the LiveStore instance.' }),
+      ),
+      sessionId: Schema.optional(
+        Schema.String.annotations({ 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({
+          description: 'Non-system table names in the connected schema',
+        }),
+        eventNames: Schema.Array(Schema.String).annotations({
+          description: 'Canonical event names defined by the connected schema',
+        }),
+      }),
+    }),
+  }),
+
+  Tool.make('livestore_instance_query', {
+    description: `Execute a raw SQL query against the connected client's local database (read-only).
+Notes:
+- The client store runs SQLite under the hood; use valid SQLite syntax.
+- Inspect your exported \`schema\` to learn table/column names.
+- \`bindValues\` must be an array (positional "?") or a record (named "$key"); do not pass a stringified JSON value.
+
+Examples (positional binds):
+{
+  "sql": "SELECT * FROM my_table WHERE userId = ? LIMIT 5",
+  "bindValues": ["u1"]
+}
+
+Examples (named binds):
+{
+  "sql": "SELECT * FROM my_table WHERE userId = $userId LIMIT 5",
+  "bindValues": { "userId": "u1" }
+}
+
+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({
+        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,
+    }),
+  }).annotate(Tool.Destructive, false),
+
+  Tool.make('livestore_instance_commit_events', {
+    description: `Commit one or more events defined by your connected LiveStore schema.
+Notes:
+- The \`name\` must match the event's canonical name declared in your schema (e.g., "v1.UserRegistered").
+- \`args\` must be a JSON object matching the event schema; do not pass a stringified JSON.
+- Use your app's own event names and fields; the example below is generic.
+ - Date fields typically accept ISO 8601 strings (e.g., "2024-01-01T00:00:00.000Z").
+
+Example parameters:
+{
+  "events": [
+    {
+      "name": "v1.EntityCreated",
+      "args": {
+        "id": "e1",
+        "title": "Hello World",
+        "createdAt": "2024-01-01T00:00:00.000Z"
+      }
+    }
+  ]
+}
+
+Returns on success:
+{ "committed": 1 }`,
+    parameters: {
+      events: Schema.Array(
+        Schema.Struct({
+          name: Schema.String.annotations({ description: 'The name of the event' }),
+          args: Schema.JsonValue.annotations({
+            description: 'The arguments for the event as a non-stringified JSON value',
+          }),
+        }),
+      ),
+    },
+    success: Schema.Struct({ committed: Schema.Number }),
+  }).annotate(Tool.Destructive, true),
+
+  Tool.make('livestore_instance_status', {
+    description: `Report the LiveStore runtime status for the current MCP session.
+
+Returns when connected:
+{
+  "_tag": "connected",
+  "storeId": "<store-id>",
+  "clientId": "<client-id>",
+  "sessionId": "<session-id>",
+  "tableCounts": { "<table>": 123 }
+}
+
+Returns when not connected:
+{
+  "_tag": "disconnected"
+}`,
+    parameters: {},
+    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({
+          description: 'Tables in the LiveStore instance with their row count',
+        }),
+      }),
+      Schema.TaggedStruct('disconnected', {}),
+    ),
+  }).annotate(Tool.Readonly, true),
+
+  Tool.make('livestore_instance_disconnect', {
+    description: `Disconnect the current LiveStore instance and release resources.
+
+Example success:
+{ "_tag": "disconnected" }`,
+    parameters: {},
+    success: Schema.TaggedStruct('disconnected', {}),
+  }),
+
+  Tool.make('livestore_sync_export', {
+    description: `Export all events from a sync backend to JSON data.
+
+This tool connects directly to the sync backend (without creating a full LiveStore instance) and pulls all events. Useful for backup, migration, and debugging.
+
+Module contract (same as livestore_instance_connect):
+\`\`\`ts
+export { schema } from './src/livestore/schema.ts'
+export const syncBackend = makeWsSync({ url: process.env.LIVESTORE_SYNC_URL ?? 'ws://localhost:8787' })
+export const syncPayload = { authToken: process.env.LIVESTORE_SYNC_AUTH_TOKEN }
+\`\`\`
+
+Example parameters:
+{
+  "configPath": "livestore-cli.config.ts",
+  "storeId": "my-store"
+}
+
+Returns on success:
+{
+  "storeId": "my-store",
+  "eventCount": 127,
+  "exportedAt": "2024-01-15T10:30:00.000Z",
+  "data": { "version": 1, "storeId": "my-store", ... }
+}`,
+    parameters: {
+      configPath: Schema.String.annotations({
+        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)' })),
+    },
+    success: Schema.Struct({
+      storeId: Schema.String,
+      eventCount: Schema.Number,
+      exportedAt: Schema.String,
+      data: Schema.JsonValue.annotations({ description: 'The export file data (can be saved or passed to import)' }),
+    }),
+  }).annotate(Tool.Readonly, true),
+
+  Tool.make('livestore_sync_import', {
+    description: `Import events from export data to a sync backend.
+
+This tool connects directly to the sync backend and pushes events. The sync backend must be empty.
+
+Example parameters:
+{
+  "configPath": "livestore-cli.config.ts",
+  "storeId": "my-store",
+  "data": { "version": 1, "storeId": "my-store", "events": [...] }
+}
+
+With options:
+{
+  "configPath": "livestore-cli.config.ts",
+  "storeId": "my-store",
+  "data": { ... },
+  "force": true,  // Import even if store ID doesn't match
+  "dryRun": true  // Validate without importing
+}
+
+Returns on success:
+{
+  "storeId": "my-store",
+  "eventCount": 127,
+  "dryRun": false
+}`,
+    parameters: {
+      configPath: Schema.String.annotations({
+        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({
+        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' }),
+      ),
+      dryRun: Schema.optional(Schema.Boolean.annotations({ description: 'Validate without actually importing' })),
+    },
+    success: Schema.Struct({
+      storeId: Schema.String,
+      eventCount: Schema.Number,
+      dryRun: Schema.Boolean,
+    }),
+  }).annotate(Tool.Destructive, true),
+)

package/src/commands/mcp.ts

@@ -1,5 +1,6 @@
 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'
@@ -9,9 +10,9 @@ 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 { toolHandlers } from './mcp-tool-handlers.ts'
 // Tools imports
-import { livestoreToolkit, toolHandlers } from './mcp-tools.ts'
+import { livestoreToolkit } from './mcp-tools-defs.ts'
 
 const LivestoreResources = Layer.mergeAll(
   McpServer.resource({

package/src/commands/new-project.ts

@@ -1,5 +1,7 @@
 import * as os from 'node:os'
 import * as nodePath from 'node:path'
+
+import { sluggify } from '@livestore/utils'
 import {
   Command,
   Console,
@@ -12,6 +14,8 @@ import {
 } from '@livestore/utils/effect'
 import { Cli } from '@livestore/utils/node'
 
+import { detectPackageManager, pmCommands } from '../package-manager.ts'
+
 // Schema for GitHub API response
 const GitHubContentSchema = Schema.Struct({
   name: Schema.String,
@@ -22,50 +26,65 @@ const GitHubContentSchema = Schema.Struct({
 
 const GitHubContentsResponseSchema = Schema.Array(GitHubContentSchema)
 
+const githubRequest = (url: string) => {
+  const request = HttpClientRequest.get(url).pipe(HttpClientRequest.setHeader('accept', 'application/vnd.github+json'))
+  const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN
+  return token === undefined ? request : request.pipe(HttpClientRequest.setHeader('authorization', `Bearer ${token}`))
+}
+
+/** 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 })),
+})
+
 // Error types
-export class ExampleNotFoundError extends Schema.TaggedError<ExampleNotFoundError>()('ExampleNotFoundError', {
+export class ExampleNotFoundError extends Schema.TaggedError<ExampleNotFoundError>('~@livestore/cli/ExampleNotFoundError')('ExampleNotFoundError', {
   exampleName: Schema.String,
   availableExamples: Schema.Array(Schema.String),
   message: Schema.String,
 }) {}
 
-export class NetworkError extends Schema.TaggedError<NetworkError>()('NetworkError', {
+export class NetworkError extends Schema.TaggedError<NetworkError>('~@livestore/cli/NetworkError')('NetworkError', {
   cause: Schema.Unknown,
   message: Schema.String,
 }) {}
 
-export class DirectoryExistsError extends Schema.TaggedError<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,
+}) {}
+
 // Fetch available examples from GitHub
-const fetchExamples = (branch: string) =>
+const fetchExamples = (ref: string) =>
   Effect.gen(function* () {
-    const url = `https://api.github.com/repos/livestorejs/livestore/contents/examples?ref=${branch}`
+    const url = `https://api.github.com/repos/livestorejs/livestore/contents/examples?ref=${ref}`
 
-    yield* Effect.log(`Fetching examples from branch: ${branch}`)
+    yield* Effect.log(`Fetching examples from ref: ${ref}`)
 
-    const request = HttpClientRequest.get(url)
+    const request = githubRequest(url)
     const response = yield* HttpClient.execute(request).pipe(
       Effect.scoped,
       Effect.catchAll(
         (error) =>
           new NetworkError({
             cause: error,
-            message: `Failed to fetch examples from GitHub: ${error}`,
+            message: `Failed to fetch examples from GitHub: ${String(error)}`,
           }),
       ),
     )
 
     const responseText = yield* response.text
 
-    const examples = yield* Schema.decodeUnknown(GitHubContentsResponseSchema)(JSON.parse(responseText)).pipe(
+    const examples = yield* Schema.decodeUnknown(Schema.parseJson(GitHubContentsResponseSchema))(responseText).pipe(
       Effect.catchAll(
         (error) =>
           new NetworkError({
             cause: error,
-            message: `Failed to parse GitHub API response: ${error}`,
+            message: `Failed to parse GitHub API response: ${String(error)}`,
           }),
       ),
     )
@@ -73,7 +92,7 @@ const fetchExamples = (branch: string) =>
     const exampleNames = examples
       .filter((item) => item.type === 'dir')
       .map((item) => item.name)
-      .sort()
+      .toSorted()
 
     yield* Effect.log(`Found ${exampleNames.length} examples: ${exampleNames.join(', ')}`)
 
@@ -84,7 +103,7 @@ const fetchExamples = (branch: string) =>
 const selectExample = (examples: string[]) =>
   Effect.gen(function* () {
     if (examples.length === 0) {
-      return yield* Effect.fail(new Error('No examples available'))
+      return yield* new NoExamplesError({ message: 'No examples available' })
     }
 
     const prompt = Cli.Prompt.select({
@@ -100,16 +119,16 @@ const selectExample = (examples: string[]) =>
   })
 
 // Download and extract example using tiged approach
-const downloadExample = (exampleName: string, branch: string, destinationPath: string) =>
+const downloadExample = (exampleName: string, ref: string, destinationPath: string) =>
   Effect.gen(function* () {
-    yield* Console.log(`📥 Downloading example "${exampleName}" from branch "${branch}"...`)
+    yield* Console.log(`📥 Downloading example "${exampleName}" from ref "${ref}"...`)
 
     const tempDir = yield* Effect.sync(() => os.tmpdir())
-    const tarballPath = nodePath.join(tempDir, `livestore-${branch}-${Date.now()}.tar.gz`)
-    const tarballUrl = `https://api.github.com/repos/livestorejs/livestore/tarball/${branch}`
+    const tarballPath = nodePath.join(tempDir, `livestore-${sluggify(ref)}-${Date.now()}.tar.gz`)
+    const tarballUrl = `https://api.github.com/repos/livestorejs/livestore/tarball/${ref}`
 
     // Download tarball directly
-    const request = HttpClientRequest.get(tarballUrl)
+    const request = githubRequest(tarballUrl)
 
     const response = yield* HttpClient.execute(request).pipe(
       Effect.scoped,
@@ -117,7 +136,7 @@ const downloadExample = (exampleName: string, branch: string, destinationPath: s
         (error) =>
           new NetworkError({
             cause: error,
-            message: `Failed to download tarball: ${error}`,
+            message: `Failed to download tarball: ${String(error)}`,
           }),
       ),
     )
@@ -142,7 +161,7 @@ const downloadExample = (exampleName: string, branch: string, destinationPath: s
         (error) =>
           new NetworkError({
             cause: error,
-            message: `Failed to extract tarball: ${error}`,
+            message: `Failed to extract tarball: ${String(error)}`,
           }),
       ),
     )
@@ -163,7 +182,7 @@ const downloadExample = (exampleName: string, branch: string, destinationPath: s
     // Check if the example exists
     const exampleExists = yield* fs.exists(exampleSourcePath)
 
-    if (!exampleExists) {
+    if (exampleExists === false) {
       return yield* new ExampleNotFoundError({
         exampleName,
         availableExamples: [],
@@ -178,7 +197,7 @@ const downloadExample = (exampleName: string, branch: string, destinationPath: s
         (error) =>
           new NetworkError({
             cause: error,
-            message: `Failed to copy example files: ${error}`,
+            message: `Failed to copy example files: ${String(error)}`,
           }),
       ),
     )
@@ -192,16 +211,21 @@ const downloadExample = (exampleName: string, branch: string, destinationPath: s
     yield* Console.log(`✅ Example "${exampleName}" created successfully at: ${destinationPath}`)
   })
 
-export const newProjectCommand = Cli.Command.make(
-  'new-project',
+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)'),
     ),
-    branch: Cli.Options.text('branch').pipe(
-      Cli.Options.withDefault('dev'),
-      Cli.Options.withDescription('Branch to fetch examples from'),
+    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(
+        '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,
@@ -210,17 +234,17 @@ export const newProjectCommand = Cli.Command.make(
   },
   Effect.fn(function* ({
     example,
-    branch,
+    ref,
     path,
   }: {
     example: Option.Option<string>
-    branch: string
+    ref: string
     path: Option.Option<string>
   }) {
     yield* Effect.log('🚀 Creating new LiveStore project...')
 
     // Fetch available examples
-    const examples = yield* fetchExamples(branch)
+    const examples = yield* fetchExamples(ref)
 
     if (examples.length === 0) {
       yield* Console.log('❌ No examples found in the repository')
@@ -232,10 +256,10 @@ export const newProjectCommand = Cli.Command.make(
     }
 
     // Select example (from CLI option or interactive prompt)
-    const selectedExample = Option.isSome(example) ? example.value : yield* selectExample(examples)
+    const selectedExample = Option.isSome(example) === true ? example.value : yield* selectExample(examples)
 
     // Validate selected example exists
-    if (!examples.includes(selectedExample)) {
+    if (examples.includes(selectedExample) === false) {
       yield* Console.log(`❌ Example "${selectedExample}" not found`)
       yield* Console.log(`Available examples: ${examples.join(', ')}`)
       return yield* new ExampleNotFoundError({
@@ -246,18 +270,48 @@ export const newProjectCommand = Cli.Command.make(
     }
 
     // Determine destination path
-    const destinationPath = Option.isSome(path) ? 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, branch, destinationPath)
+    yield* downloadExample(selectedExample, ref, destinationPath)
+
+    // Detect available run script (dev or start) from the created project's package.json.
+    // Some examples use "dev" (web projects), others use "start" (Expo projects),
+    // and some have no run script at all (e.g., node-effect-cli).
+    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(
+      Effect.map((pkg) => ('dev' in pkg.scripts ? ('dev' as const) : ('start' as const))),
+      Effect.orElseSucceed(() => undefined),
+    )
+
+    // Detect which package manager was used to invoke the CLI (via npm_config_user_agent).
+    // This ensures the "next steps" instructions match how the user ran the create command.
+    const pmResult = detectPackageManager()
 
-    // Success message
     yield* Console.log('\n🎉 Project created successfully!')
     yield* Console.log(`📁 Location: ${destinationPath}`)
     yield* Console.log('\n📋 Next steps:')
     yield* Console.log(`   cd ${nodePath.basename(destinationPath)}`)
-    yield* Console.log('   pnpm install    # Install dependencies')
-    yield* Console.log('   pnpm dev        # Start development server')
+
+    // Yarn is not recommended for LiveStore projects. When detected, show a warning
+    // and suggest using bun instead for the next steps.
+    if (pmResult._tag === 'unsupported') {
+      yield* Console.log('   bun install    # Install dependencies (yarn is not recommended)')
+      if (runScript !== undefined) {
+        yield* Console.log(`   bun ${runScript}        # Start development server`)
+      }
+      yield* Console.log('\n⚠️  Yarn is not recommended for LiveStore projects.')
+      yield* Console.log('   We recommend using bun, pnpm, or npm instead.')
+      yield* Console.log('   The commands above use bun by default.')
+    } else {
+      const pm = pmResult.pm
+      yield* Console.log(`   ${pmCommands.install[pm]}    # Install dependencies`)
+      if (runScript !== undefined) {
+        yield* Console.log(`   ${pmCommands.run[pm](runScript)}        # Start development server`)
+      }
+    }
     yield* Console.log('\n💡 Tip: Run `git init` if you want to initialize version control')
   }),
 )