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

package/dist/mcp-content/schemas/social.js

@@ -0,0 +1,339 @@
+export const socialSchemaContent = `import { Events, makeSchema, Schema, SessionIdSymbol, State } from '@livestore/livestore'
+
+// Social network with activity feeds and real-time interactions
+export const tables = {
+  users: State.SQLite.table({
+    name: 'users',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      username: State.SQLite.text(),
+      email: State.SQLite.text(),
+      displayName: State.SQLite.text(),
+      bio: State.SQLite.text({ nullable: true }),
+      avatarUrl: State.SQLite.text({ nullable: true }),
+      isVerified: State.SQLite.boolean({ default: false }),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      lastActiveAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+      // Privacy settings
+      isPrivate: State.SQLite.boolean({ default: false }),
+      allowsFollowers: State.SQLite.boolean({ default: true }),
+    },
+  }),
+  
+  posts: State.SQLite.table({
+    name: 'posts',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      authorId: State.SQLite.text(),
+      content: State.SQLite.text(),
+      mediaUrls: State.SQLite.text({ nullable: true }), // JSON array of media URLs
+      replyToId: State.SQLite.text({ nullable: true }), // For threading
+      visibility: State.SQLite.text({ default: 'public' }), // public, followers, private
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      editedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  follows: State.SQLite.table({
+    name: 'follows',
+    columns: {
+      followerId: State.SQLite.text(),
+      followingId: State.SQLite.text(),
+      status: State.SQLite.text({ default: 'active' }), // active, pending, blocked
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      approvedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  likes: State.SQLite.table({
+    name: 'likes',
+    columns: {
+      userId: State.SQLite.text(),
+      postId: State.SQLite.text(),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  // Aggregate tables for performance (eventually consistent)
+  postStats: State.SQLite.table({
+    name: 'post_stats',
+    columns: {
+      postId: State.SQLite.text({ primaryKey: true }),
+      likeCount: State.SQLite.integer({ default: 0 }),
+      replyCount: State.SQLite.integer({ default: 0 }),
+      shareCount: State.SQLite.integer({ default: 0 }),
+      lastUpdated: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  userStats: State.SQLite.table({
+    name: 'user_stats', 
+    columns: {
+      userId: State.SQLite.text({ primaryKey: true }),
+      followerCount: State.SQLite.integer({ default: 0 }),
+      followingCount: State.SQLite.integer({ default: 0 }),
+      postCount: State.SQLite.integer({ default: 0 }),
+      lastUpdated: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  // Client-side state for UI
+  feedState: State.SQLite.clientDocument({
+    name: 'feedState',
+    schema: Schema.Struct({
+      currentFeed: Schema.Literal('home', 'discover', 'following'),
+      lastRefresh: Schema.Date,
+      scrollPosition: Schema.Number,
+    }),
+    default: { 
+      id: SessionIdSymbol, 
+      value: { currentFeed: 'home', lastRefresh: new Date(), scrollPosition: 0 }
+    },
+  }),
+}
+
+export const events = {
+  // User events
+  userCreated: Events.synced({
+    name: 'v1.UserCreated',
+    schema: Schema.Struct({
+      id: Schema.String,
+      username: Schema.String,
+      email: Schema.String,
+      displayName: Schema.String,
+      createdAt: Schema.Date,
+    }),
+  }),
+  
+  userProfileUpdated: Events.synced({
+    name: 'v1.UserProfileUpdated',
+    schema: Schema.Struct({
+      id: Schema.String,
+      displayName: Schema.NullOr(Schema.String),
+      bio: Schema.NullOr(Schema.String),
+      avatarUrl: Schema.NullOr(Schema.String),
+    }),
+  }),
+  
+  userPrivacySettingsChanged: Events.synced({
+    name: 'v1.UserPrivacySettingsChanged',
+    schema: Schema.Struct({
+      id: Schema.String,
+      isPrivate: Schema.Boolean,
+      allowsFollowers: Schema.Boolean,
+    }),
+  }),
+  
+  userLastActiveUpdated: Events.synced({
+    name: 'v1.UserLastActiveUpdated',
+    schema: Schema.Struct({
+      id: Schema.String,
+      lastActiveAt: Schema.Date,
+    }),
+  }),
+  
+  // Post events
+  postCreated: Events.synced({
+    name: 'v1.PostCreated',
+    schema: Schema.Struct({
+      id: Schema.String,
+      authorId: Schema.String,
+      content: Schema.String,
+      mediaUrls: Schema.NullOr(Schema.Array(Schema.String)),
+      replyToId: Schema.NullOr(Schema.String),
+      visibility: Schema.Literal('public', 'followers', 'private'),
+      createdAt: Schema.Date,
+    }),
+  }),
+  
+  postEdited: Events.synced({
+    name: 'v1.PostEdited',
+    schema: Schema.Struct({
+      id: Schema.String,
+      content: Schema.String,
+      editedAt: Schema.Date,
+    }),
+  }),
+  
+  postDeleted: Events.synced({
+    name: 'v1.PostDeleted',
+    schema: Schema.Struct({
+      id: Schema.String,
+      deletedAt: Schema.Date,
+    }),
+  }),
+  
+  // Social interaction events
+  followRequested: Events.synced({
+    name: 'v1.FollowRequested',
+    schema: Schema.Struct({
+      followerId: Schema.String,
+      followingId: Schema.String,
+      createdAt: Schema.Date,
+    }),
+  }),
+  
+  followApproved: Events.synced({
+    name: 'v1.FollowApproved',
+    schema: Schema.Struct({
+      followerId: Schema.String,
+      followingId: Schema.String,
+      approvedAt: Schema.Date,
+    }),
+  }),
+  
+  unfollowed: Events.synced({
+    name: 'v1.Unfollowed',
+    schema: Schema.Struct({
+      followerId: Schema.String,
+      followingId: Schema.String,
+    }),
+  }),
+  
+  postLiked: Events.synced({
+    name: 'v1.PostLiked',
+    schema: Schema.Struct({
+      userId: Schema.String,
+      postId: Schema.String,
+      createdAt: Schema.Date,
+    }),
+  }),
+  
+  postUnliked: Events.synced({
+    name: 'v1.PostUnliked',
+    schema: Schema.Struct({
+      userId: Schema.String,
+      postId: Schema.String,
+    }),
+  }),
+  
+  // Local UI state
+  feedStateUpdated: tables.feedState.set,
+}
+
+// Materializers with eventual consistency for aggregates
+const materializers = State.SQLite.materializers(events, {
+  // User materializers
+  'v1.UserCreated': ({ id, username, email, displayName, createdAt }) => [
+    tables.users.insert({ id, username, email, displayName, createdAt }),
+    tables.userStats.insert({ userId: id, lastUpdated: createdAt }),
+  ],
+  
+  'v1.UserProfileUpdated': ({ id, displayName, bio, avatarUrl }) =>
+    tables.users.update({ displayName, bio, avatarUrl }).where({ id }),
+    
+  'v1.UserPrivacySettingsChanged': ({ id, isPrivate, allowsFollowers }) =>
+    tables.users.update({ isPrivate, allowsFollowers }).where({ id }),
+    
+  'v1.UserLastActiveUpdated': ({ id, lastActiveAt }) =>
+    tables.users.update({ lastActiveAt }).where({ id }),
+    
+  // Post materializers
+  'v1.PostCreated': ({ id, authorId, content, mediaUrls, replyToId, visibility, createdAt }) => [
+    tables.posts.insert({ 
+      id, 
+      authorId, 
+      content, 
+      mediaUrls: mediaUrls ? JSON.stringify(mediaUrls) : null,
+      replyToId, 
+      visibility, 
+      createdAt 
+    }),
+    tables.postStats.insert({ postId: id, lastUpdated: createdAt }),
+    // Update user post count
+    tables.userStats.update({ 
+      postCount: tables.userStats.select('postCount').where({ userId: authorId }).scalar() + 1,
+      lastUpdated: createdAt
+    }).where({ userId: authorId }),
+  ],
+  
+  'v1.PostEdited': ({ id, content, editedAt }) =>
+    tables.posts.update({ content, editedAt }).where({ id }),
+    
+  'v1.PostDeleted': ({ id, deletedAt }) =>
+    tables.posts.update({ deletedAt }).where({ id }),
+    
+  // Follow materializers
+  'v1.FollowRequested': ({ followerId, followingId, createdAt }) =>
+    tables.follows.insert({ followerId, followingId, status: 'pending', createdAt }),
+    
+  'v1.FollowApproved': ({ followerId, followingId, approvedAt }) => [
+    tables.follows.update({ status: 'active', approvedAt }).where({ followerId, followingId }),
+    // Update follower counts
+    tables.userStats.update({ 
+      followerCount: tables.userStats.select('followerCount').where({ userId: followingId }).scalar() + 1,
+      lastUpdated: approvedAt
+    }).where({ userId: followingId }),
+    tables.userStats.update({ 
+      followingCount: tables.userStats.select('followingCount').where({ userId: followerId }).scalar() + 1,
+      lastUpdated: approvedAt
+    }).where({ userId: followerId }),
+  ],
+  
+  'v1.Unfollowed': ({ followerId, followingId }) => [
+    tables.follows.delete().where({ followerId, followingId }),
+    // Update follower counts (eventual consistency)
+    tables.userStats.update({ 
+      followerCount: Math.max(0, tables.userStats.select('followerCount').where({ userId: followingId }).scalar() - 1),
+      lastUpdated: new Date()
+    }).where({ userId: followingId }),
+    tables.userStats.update({ 
+      followingCount: Math.max(0, tables.userStats.select('followingCount').where({ userId: followerId }).scalar() - 1),
+      lastUpdated: new Date()
+    }).where({ userId: followerId }),
+  ],
+  
+  // Like materializers (idempotent)
+  'v1.PostLiked': ({ userId, postId, createdAt }) => [
+    tables.likes.insert({ userId, postId, createdAt }),
+    // Update like count
+    tables.postStats.update({ 
+      likeCount: tables.postStats.select('likeCount').where({ postId }).scalar() + 1,
+      lastUpdated: createdAt
+    }).where({ postId }),
+  ],
+  
+  'v1.PostUnliked': ({ userId, postId }) => [
+    tables.likes.delete().where({ userId, postId }),
+    // Update like count
+    tables.postStats.update({ 
+      likeCount: Math.max(0, tables.postStats.select('likeCount').where({ postId }).scalar() - 1),
+      lastUpdated: new Date()
+    }).where({ postId }),
+  ],
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+
+// Example queries for activity feeds:
+//
+// // Home feed - posts from followed users
+// const homeFeed$ = (userId: string) => queryDb(
+//   tables.posts
+//     .select()
+//     .join(tables.follows, 'authorId', 'followingId')
+//     .join(tables.users, 'authorId', 'id')
+//     .leftJoin(tables.postStats, 'id', 'postId')
+//     .where({ 
+//       followerId: userId, 
+//       'follows.status': 'active',
+//       'posts.deletedAt': null,
+//       'posts.visibility': ['public', 'followers']
+//     })
+//     .orderBy('createdAt', 'desc')
+//     .limit(50),
+//   { label: \`homeFeed-\${userId}\` }
+// )
+//
+// // User profile with stats
+// const userProfile$ = (username: string) => queryDb(
+//   tables.users
+//     .select()
+//     .leftJoin(tables.userStats, 'id', 'userId')
+//     .where({ username }),
+//   { label: \`userProfile-\${username}\` }
+// )`;
+//# sourceMappingURL=social.js.map

package/dist/mcp-content/schemas/social.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"social.js","sourceRoot":"","sources":["../../../src/mcp-content/schemas/social.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiV9B,CAAA"}

package/dist/mcp-content/schemas/todo.d.ts

@@ -0,0 +1,2 @@
+export declare const todoSchemaContent = "import { Events, makeSchema, Schema, SessionIdSymbol, State } from '@livestore/livestore'\n\n// State tables - Define your application state as SQLite tables\nexport const tables = {\n  todos: State.SQLite.table({\n    name: 'todos',\n    columns: {\n      id: State.SQLite.text({ primaryKey: true }),\n      title: State.SQLite.text({ default: '' }),\n      completed: State.SQLite.boolean({ default: false }),\n      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),\n      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),\n      position: State.SQLite.real(), // For ordering - enables conflict-free reordering\n    },\n  }),\n  tags: State.SQLite.table({\n    name: 'tags',\n    columns: {\n      id: State.SQLite.text({ primaryKey: true }),\n      name: State.SQLite.text(),\n      color: State.SQLite.text({ nullable: true }),\n      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),\n      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),\n    },\n  }),\n  todoTags: State.SQLite.table({\n    name: 'todo_tags',\n    columns: {\n      todoId: State.SQLite.text(),\n      tagId: State.SQLite.text(),\n      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),\n    },\n  }),\n  // Client-only state for UI (not synced)\n  uiState: State.SQLite.clientDocument({\n    name: 'uiState',\n    schema: Schema.Struct({ \n      newTodoText: Schema.String, \n      filter: Schema.Literal('all', 'active', 'completed'),\n      selectedTags: Schema.Array(Schema.String)\n    }),\n    default: { id: SessionIdSymbol, value: { newTodoText: '', filter: 'all', selectedTags: [] } },\n  }),\n}\n\n// Events - Define state changes as events for reliable sync and replay\nexport const events = {\n  // Todo events\n  todoCreated: Events.synced({\n    name: 'v1.TodoCreated',\n    schema: Schema.Struct({ \n      id: Schema.String, \n      title: Schema.String,\n      createdAt: Schema.Date,\n      position: Schema.Number\n    }),\n  }),\n  todoCompleted: Events.synced({\n    name: 'v1.TodoCompleted',\n    schema: Schema.Struct({ id: Schema.String }),\n  }),\n  todoUncompleted: Events.synced({\n    name: 'v1.TodoUncompleted', \n    schema: Schema.Struct({ id: Schema.String }),\n  }),\n  todoTitleChanged: Events.synced({\n    name: 'v1.TodoTitleChanged',\n    schema: Schema.Struct({ id: Schema.String, title: Schema.String }),\n  }),\n  todoReordered: Events.synced({\n    name: 'v1.TodoReordered',\n    schema: Schema.Struct({ id: Schema.String, position: Schema.Number }),\n  }),\n  todoDeleted: Events.synced({\n    name: 'v1.TodoDeleted',\n    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),\n  }),\n  todosCleared: Events.synced({\n    name: 'v1.TodosCleared', \n    schema: Schema.Struct({ deletedAt: Schema.Date }),\n  }),\n  \n  // Tag events\n  tagCreated: Events.synced({\n    name: 'v1.TagCreated',\n    schema: Schema.Struct({ \n      id: Schema.String, \n      name: Schema.String, \n      color: Schema.NullOr(Schema.String),\n      createdAt: Schema.Date\n    }),\n  }),\n  tagDeleted: Events.synced({\n    name: 'v1.TagDeleted',\n    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),\n  }),\n  \n  // Todo-Tag relationship events\n  todoTagged: Events.synced({\n    name: 'v1.TodoTagged',\n    schema: Schema.Struct({ todoId: Schema.String, tagId: Schema.String, createdAt: Schema.Date }),\n  }),\n  todoUntagged: Events.synced({\n    name: 'v1.TodoUntagged',\n    schema: Schema.Struct({ todoId: Schema.String, tagId: Schema.String }),\n  }),\n  \n  // UI state events (local only)\n  uiStateSet: tables.uiState.set,\n}\n\n// Materializers - Map events to state changes with conflict-free semantics\nconst materializers = State.SQLite.materializers(events, {\n  // Todo materializers\n  'v1.TodoCreated': ({ id, title, createdAt, position }) => \n    tables.todos.insert({ id, title, completed: false, createdAt, position }),\n    \n  'v1.TodoCompleted': ({ id }) => \n    tables.todos.update({ completed: true }).where({ id }),\n    \n  'v1.TodoUncompleted': ({ id }) => \n    tables.todos.update({ completed: false }).where({ id }),\n    \n  'v1.TodoTitleChanged': ({ id, title }) => \n    tables.todos.update({ title }).where({ id }),\n    \n  'v1.TodoReordered': ({ id, position }) => \n    tables.todos.update({ position }).where({ id }),\n    \n  'v1.TodoDeleted': ({ id, deletedAt }) => \n    tables.todos.update({ deletedAt }).where({ id }),\n    \n  'v1.TodosCleared': ({ deletedAt }) => \n    tables.todos.update({ deletedAt }).where({ completed: true, deletedAt: null }),\n    \n  // Tag materializers  \n  'v1.TagCreated': ({ id, name, color, createdAt }) => \n    tables.tags.insert({ id, name, color, createdAt }),\n    \n  'v1.TagDeleted': ({ id, deletedAt }) => \n    tables.tags.update({ deletedAt }).where({ id }),\n    \n  // Todo-Tag relationship materializers\n  'v1.TodoTagged': ({ todoId, tagId, createdAt }) => \n    tables.todoTags.insert({ todoId, tagId, createdAt }),\n    \n  'v1.TodoUntagged': ({ todoId, tagId }) => \n    tables.todoTags.delete().where({ todoId, tagId }),\n})\n\nconst state = State.SQLite.makeState({ tables, materializers })\n\nexport const schema = makeSchema({ events, state })\n\n// Example usage:\n// \n// import { queryDb, dispatchEvent } from '@livestore/livestore'\n// import { schema, events, tables } from './schema.js'\n//\n// // Query active todos\n// const activeTodos$ = queryDb(\n//   tables.todos.select().where({ deletedAt: null, completed: false }).orderBy('position'),\n//   { label: 'activeTodos' }\n// )\n//\n// // Create a new todo\n// const createTodo = (title: string) => {\n//   const id = crypto.randomUUID()\n//   const position = Date.now() // Simple position strategy\n//   dispatchEvent(events.todoCreated({ id, title, createdAt: new Date(), position }))\n// }";
+//# sourceMappingURL=todo.d.ts.map

package/dist/mcp-content/schemas/todo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo.d.ts","sourceRoot":"","sources":["../../../src/mcp-content/schemas/todo.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,8xLA0KzB,CAAA"}

package/dist/mcp-content/schemas/todo.js

@@ -0,0 +1,172 @@
+export const todoSchemaContent = `import { Events, makeSchema, Schema, SessionIdSymbol, State } from '@livestore/livestore'
+
+// State tables - Define your application state as SQLite tables
+export const tables = {
+  todos: State.SQLite.table({
+    name: 'todos',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      title: State.SQLite.text({ default: '' }),
+      completed: State.SQLite.boolean({ default: false }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      position: State.SQLite.real(), // For ordering - enables conflict-free reordering
+    },
+  }),
+  tags: State.SQLite.table({
+    name: 'tags',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      name: State.SQLite.text(),
+      color: State.SQLite.text({ nullable: true }),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    },
+  }),
+  todoTags: State.SQLite.table({
+    name: 'todo_tags',
+    columns: {
+      todoId: State.SQLite.text(),
+      tagId: State.SQLite.text(),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  // Client-only state for UI (not synced)
+  uiState: State.SQLite.clientDocument({
+    name: 'uiState',
+    schema: Schema.Struct({ 
+      newTodoText: Schema.String, 
+      filter: Schema.Literal('all', 'active', 'completed'),
+      selectedTags: Schema.Array(Schema.String)
+    }),
+    default: { id: SessionIdSymbol, value: { newTodoText: '', filter: 'all', selectedTags: [] } },
+  }),
+}
+
+// Events - Define state changes as events for reliable sync and replay
+export const events = {
+  // Todo events
+  todoCreated: Events.synced({
+    name: 'v1.TodoCreated',
+    schema: Schema.Struct({ 
+      id: Schema.String, 
+      title: Schema.String,
+      createdAt: Schema.Date,
+      position: Schema.Number
+    }),
+  }),
+  todoCompleted: Events.synced({
+    name: 'v1.TodoCompleted',
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoUncompleted: Events.synced({
+    name: 'v1.TodoUncompleted', 
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoTitleChanged: Events.synced({
+    name: 'v1.TodoTitleChanged',
+    schema: Schema.Struct({ id: Schema.String, title: Schema.String }),
+  }),
+  todoReordered: Events.synced({
+    name: 'v1.TodoReordered',
+    schema: Schema.Struct({ id: Schema.String, position: Schema.Number }),
+  }),
+  todoDeleted: Events.synced({
+    name: 'v1.TodoDeleted',
+    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
+  }),
+  todosCleared: Events.synced({
+    name: 'v1.TodosCleared', 
+    schema: Schema.Struct({ deletedAt: Schema.Date }),
+  }),
+  
+  // Tag events
+  tagCreated: Events.synced({
+    name: 'v1.TagCreated',
+    schema: Schema.Struct({ 
+      id: Schema.String, 
+      name: Schema.String, 
+      color: Schema.NullOr(Schema.String),
+      createdAt: Schema.Date
+    }),
+  }),
+  tagDeleted: Events.synced({
+    name: 'v1.TagDeleted',
+    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
+  }),
+  
+  // Todo-Tag relationship events
+  todoTagged: Events.synced({
+    name: 'v1.TodoTagged',
+    schema: Schema.Struct({ todoId: Schema.String, tagId: Schema.String, createdAt: Schema.Date }),
+  }),
+  todoUntagged: Events.synced({
+    name: 'v1.TodoUntagged',
+    schema: Schema.Struct({ todoId: Schema.String, tagId: Schema.String }),
+  }),
+  
+  // UI state events (local only)
+  uiStateSet: tables.uiState.set,
+}
+
+// Materializers - Map events to state changes with conflict-free semantics
+const materializers = State.SQLite.materializers(events, {
+  // Todo materializers
+  'v1.TodoCreated': ({ id, title, createdAt, position }) => 
+    tables.todos.insert({ id, title, completed: false, createdAt, position }),
+    
+  'v1.TodoCompleted': ({ id }) => 
+    tables.todos.update({ completed: true }).where({ id }),
+    
+  'v1.TodoUncompleted': ({ id }) => 
+    tables.todos.update({ completed: false }).where({ id }),
+    
+  'v1.TodoTitleChanged': ({ id, title }) => 
+    tables.todos.update({ title }).where({ id }),
+    
+  'v1.TodoReordered': ({ id, position }) => 
+    tables.todos.update({ position }).where({ id }),
+    
+  'v1.TodoDeleted': ({ id, deletedAt }) => 
+    tables.todos.update({ deletedAt }).where({ id }),
+    
+  'v1.TodosCleared': ({ deletedAt }) => 
+    tables.todos.update({ deletedAt }).where({ completed: true, deletedAt: null }),
+    
+  // Tag materializers  
+  'v1.TagCreated': ({ id, name, color, createdAt }) => 
+    tables.tags.insert({ id, name, color, createdAt }),
+    
+  'v1.TagDeleted': ({ id, deletedAt }) => 
+    tables.tags.update({ deletedAt }).where({ id }),
+    
+  // Todo-Tag relationship materializers
+  'v1.TodoTagged': ({ todoId, tagId, createdAt }) => 
+    tables.todoTags.insert({ todoId, tagId, createdAt }),
+    
+  'v1.TodoUntagged': ({ todoId, tagId }) => 
+    tables.todoTags.delete().where({ todoId, tagId }),
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+
+// Example usage:
+// 
+// import { queryDb, dispatchEvent } from '@livestore/livestore'
+// import { schema, events, tables } from './schema.js'
+//
+// // Query active todos
+// const activeTodos$ = queryDb(
+//   tables.todos.select().where({ deletedAt: null, completed: false }).orderBy('position'),
+//   { label: 'activeTodos' }
+// )
+//
+// // Create a new todo
+// const createTodo = (title: string) => {
+//   const id = crypto.randomUUID()
+//   const position = Date.now() // Simple position strategy
+//   dispatchEvent(events.todoCreated({ id, title, createdAt: new Date(), position }))
+// }`;
+//# sourceMappingURL=todo.js.map

package/dist/mcp-content/schemas/todo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"todo.js","sourceRoot":"","sources":["../../../src/mcp-content/schemas/todo.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0K5B,CAAA"}

package/dist/mod.d.ts

@@ -0,0 +1,2 @@
+export { command as LivestoreCliCommand } from './cli.ts';
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,UAAU,CAAA"}

package/dist/mod.js

@@ -0,0 +1,2 @@
+export { command as LivestoreCliCommand } from "./cli.js";
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,UAAU,CAAA"}

package/dist/test-tool.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-tool.d.ts.map

package/dist/test-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-tool.d.ts","sourceRoot":"","sources":["../src/test-tool.ts"],"names":[],"mappings":""}

package/dist/test-tool.js

@@ -0,0 +1,57 @@
+// Test file to diagnose AiTool.make issue
+import { AiTool, AiToolkit, Schema } from '@livestore/utils/effect';
+console.log('Testing AiTool.make...');
+try {
+    // Test 1: Simplest possible tool
+    const tool1 = AiTool.make("test_tool", {
+        description: "A test tool",
+    });
+    console.log('✅ Simple tool created:', tool1.name);
+}
+catch (error) {
+    console.error('❌ Simple tool failed:', error);
+}
+try {
+    // Test 2: Tool with parameters
+    const tool2 = AiTool.make("test_with_params", {
+        description: "A test tool with params",
+        parameters: {
+            message: Schema.String
+        }
+    });
+    console.log('✅ Tool with params created:', tool2.name);
+}
+catch (error) {
+    console.error('❌ Tool with params failed:', error);
+}
+try {
+    // Test 3: Tool with annotated parameters (Tim Smart's style)
+    const tool3 = AiTool.make("test_annotated", {
+        description: "A test tool with annotated params",
+        parameters: {
+            message: Schema.String.annotations({
+                description: "The message to process"
+            })
+        }
+    });
+    console.log('✅ Tool with annotated params created:', tool3.name);
+}
+catch (error) {
+    console.error('❌ Tool with annotated params failed:', error);
+}
+try {
+    // Test 4: Create a toolkit
+    const tool = AiTool.make("toolkit_tool", {
+        description: "A tool for toolkit",
+        parameters: {
+            input: Schema.String
+        }
+    });
+    const toolkit = AiToolkit.make([tool]);
+    console.log('✅ Toolkit created');
+}
+catch (error) {
+    console.error('❌ Toolkit failed:', error);
+}
+console.log('\nAll tests completed.');
+//# sourceMappingURL=test-tool.js.map

package/dist/test-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-tool.js","sourceRoot":"","sources":["../src/test-tool.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAEnE,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAA;AAErC,IAAI,CAAC;IACH,iCAAiC;IACjC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE;QACrC,WAAW,EAAE,aAAa;KAC3B,CAAC,CAAA;IACF,OAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;AACnD,CAAC;AAAC,OAAO,KAAK,EAAE,CAAC;IACf,OAAO,CAAC,KAAK,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAA;AAC/C,CAAC;AAED,IAAI,CAAC;IACH,+BAA+B;IAC/B,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE;QAC5C,WAAW,EAAE,yBAAyB;QACtC,UAAU,EAAE;YACV,OAAO,EAAE,MAAM,CAAC,MAAM;SACvB;KACF,CAAC,CAAA;IACF,OAAO,CAAC,GAAG,CAAC,6BAA6B,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;AACxD,CAAC;AAAC,OAAO,KAAK,EAAE,CAAC;IACf,OAAO,CAAC,KAAK,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAA;AACpD,CAAC;AAED,IAAI,CAAC;IACH,6DAA6D;IAC7D,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE;QAC1C,WAAW,EAAE,mCAAmC;QAChD,UAAU,EAAE;YACV,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC;gBACjC,WAAW,EAAE,wBAAwB;aACtC,CAAC;SACH;KACF,CAAC,CAAA;IACF,OAAO,CAAC,GAAG,CAAC,uCAAuC,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;AAClE,CAAC;AAAC,OAAO,KAAK,EAAE,CAAC;IACf,OAAO,CAAC,KAAK,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAA;AAC9D,CAAC;AAED,IAAI,CAAC;IACH,2BAA2B;IAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE;QACvC,WAAW,EAAE,oBAAoB;QACjC,UAAU,EAAE;YACV,KAAK,EAAE,MAAM,CAAC,MAAM;SACrB;KACF,CAAC,CAAA;IAEF,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;IACtC,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAA;AAClC,CAAC;AAAC,OAAO,KAAK,EAAE,CAAC;IACf,OAAO,CAAC,KAAK,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAA;AAC3C,CAAC;AAED,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAA"}