create-keel-and-deck-app 0.1.0

package/template/src/stores/feeds.ts

@@ -0,0 +1,34 @@
+import { create } from "zustand";
+import { mergeFeedItem } from "@deck-ui/chat";
+import type { FeedItem } from "@deck-ui/chat";
+
+interface FeedState {
+  items: Record<string, FeedItem[]>;
+  pushFeedItem: (sessionKey: string, item: FeedItem) => void;
+  setFeed: (sessionKey: string, items: FeedItem[]) => void;
+  clearFeed: (sessionKey: string) => void;
+}
+
+export const useFeedStore = create<FeedState>((set) => ({
+  items: {},
+
+  pushFeedItem: (sessionKey, item) =>
+    set((s) => ({
+      items: {
+        ...s.items,
+        [sessionKey]: mergeFeedItem(s.items[sessionKey] ?? [], item),
+      },
+    })),
+
+  setFeed: (sessionKey, items) =>
+    set((s) => ({
+      items: { ...s.items, [sessionKey]: items },
+    })),
+
+  clearFeed: (sessionKey) =>
+    set((s) => {
+      const next = { ...s.items };
+      delete next[sessionKey];
+      return { items: next };
+    }),
+}));

package/template/src/stores/issues.ts

@@ -0,0 +1,35 @@
+import { create } from "zustand";
+import { tauriIssues } from "../lib/tauri";
+import type { Issue } from "../lib/types";
+
+interface IssueState {
+  issues: Issue[];
+  loading: boolean;
+  loadIssues: (projectId: string) => Promise<void>;
+  createIssue: (projectId: string, title: string, description: string) => Promise<void>;
+  updateIssueStatus: (issueId: string, status: string) => void;
+}
+
+export const useIssueStore = create<IssueState>((set, get) => ({
+  issues: [],
+  loading: false,
+
+  loadIssues: async (projectId) => {
+    set({ loading: true });
+    const issues = await tauriIssues.list(projectId);
+    set({ issues, loading: false });
+  },
+
+  createIssue: async (projectId, title, description) => {
+    const issue = await tauriIssues.create(projectId, title, description);
+    set((s) => ({ issues: [...s.issues, issue] }));
+  },
+
+  updateIssueStatus: (issueId, status) => {
+    set((s) => ({
+      issues: s.issues.map((i) =>
+        i.id === issueId ? { ...i, status } : i,
+      ),
+    }));
+  },
+}));

package/template/src/stores/memory.ts

@@ -0,0 +1,30 @@
+import { create } from "zustand";
+import type { Memory } from "@deck-ui/memory";
+import { tauriMemory } from "../lib/tauri";
+
+interface MemoryState {
+  memories: Memory[];
+  loading: boolean;
+  loadMemories: (projectId: string) => Promise<void>;
+  deleteMemory: (memoryId: string) => void;
+}
+
+export const useMemoryStore = create<MemoryState>((set) => ({
+  memories: [],
+  loading: false,
+
+  loadMemories: async (projectId) => {
+    set({ loading: true });
+    try {
+      const memories = await tauriMemory.list(projectId);
+      set({ memories, loading: false });
+    } catch {
+      set({ loading: false });
+    }
+  },
+
+  deleteMemory: (memoryId) =>
+    set((s) => ({
+      memories: s.memories.filter((m) => m.id !== memoryId),
+    })),
+}));

package/template/src/stores/ui.ts

@@ -0,0 +1,17 @@
+import { create } from "zustand";
+
+export type ViewMode = "files" | "instructions";
+
+interface UIState {
+  viewMode: ViewMode;
+  chatOpen: boolean;
+  setViewMode: (mode: ViewMode) => void;
+  setChatOpen: (open: boolean) => void;
+}
+
+export const useUIStore = create<UIState>((set) => ({
+  viewMode: "files",
+  chatOpen: false,
+  setViewMode: (viewMode) => set({ viewMode }),
+  setChatOpen: (chatOpen) => set({ chatOpen }),
+}));

package/template/src/styles/globals.css

@@ -0,0 +1,24 @@
+@import "tailwindcss";
+@import "@deck-ui/core/src/globals.css";
+@import "@deck-ui/core/src/styles.css";
+@import "@deck-ui/chat/src/styles.css";
+
+/* Scan local source + deck-ui packages for Tailwind classes */
+@source "../";
+@source "../../node_modules/@deck-ui/board/src";
+@source "../../node_modules/@deck-ui/chat/src";
+@source "../../node_modules/@deck-ui/layout/src";
+@source "../../node_modules/@deck-ui/core/src";
+@source "../../node_modules/@deck-ui/skills/src";
+@source "../../node_modules/@deck-ui/routines/src";
+@source "../../node_modules/@deck-ui/connections/src";
+@source "../../node_modules/@deck-ui/events/src";
+@source "../../node_modules/@deck-ui/memory/src";
+@source "../../node_modules/@deck-ui/review/src";
+
+body {
+  margin: 0;
+  overflow: hidden;
+  font-family: ui-sans-serif, -apple-system, system-ui, "Segoe UI", Helvetica,
+    Arial, sans-serif;
+}

package/template/src-tauri/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "{{APP_NAME_SNAKE}}"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "{{APP_NAME_SNAKE}}_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = [] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["full"] }
+uuid = { version = "1", features = ["v4"] }
+keel-tauri = { git = "https://github.com/ja-818/keel-and-deck.git" }
+keel-db = { git = "https://github.com/ja-818/keel-and-deck.git" }
+keel-sessions = { git = "https://github.com/ja-818/keel-and-deck.git" }
+keel-events = { git = "https://github.com/ja-818/keel-and-deck.git" }
+keel-scheduler = { git = "https://github.com/ja-818/keel-and-deck.git" }
+keel-channels = { git = "https://github.com/ja-818/keel-and-deck.git" }
+keel-memory = { git = "https://github.com/ja-818/keel-and-deck.git" }
+anyhow = "1"
+chrono = { version = "0.4", features = ["serde"] }
+libsql = "0.6"

package/template/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/template/src-tauri/capabilities/default.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://raw.githubusercontent.com/nickelpack/tauri/v2/crates/tauri-utils/schema.json",
+  "identifier": "default",
+  "description": "Default capability for the main window",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "core:event:default",
+    "core:event:allow-listen",
+    "core:event:allow-emit"
+  ]
+}

package/template/src-tauri/src/commands/channels.rs

@@ -0,0 +1,119 @@
+use keel_tauri::state::AppState;
+use tauri::State;
+
+/// List all configured channels from the channels table.
+/// Returns an empty list if the table does not exist yet.
+#[tauri::command]
+pub async fn list_channels(
+    state: State<'_, AppState>,
+) -> Result<Vec<serde_json::Value>, String> {
+    let rows = state
+        .db
+        .conn()
+        .query(
+            "SELECT id, channel_type, name, status, config, created_at \
+             FROM channels ORDER BY created_at DESC",
+            libsql::params![],
+        )
+        .await;
+
+    match rows {
+        Ok(mut rows) => {
+            let mut results = Vec::new();
+            while let Ok(Some(row)) = rows.next().await {
+                let entry = serde_json::json!({
+                    "id": row.get::<String>(0).unwrap_or_default(),
+                    "channel_type": row.get::<String>(1).unwrap_or_default(),
+                    "name": row.get::<String>(2).unwrap_or_default(),
+                    "status": row.get::<String>(3).unwrap_or_default(),
+                    "config": row.get::<String>(4).unwrap_or_default(),
+                    "created_at": row.get::<String>(5).unwrap_or_default(),
+                });
+                results.push(entry);
+            }
+            Ok(results)
+        }
+        Err(_) => Ok(Vec::new()),
+    }
+}
+
+#[tauri::command]
+pub async fn add_channel(
+    state: State<'_, AppState>,
+    channel_type: String,
+    name: String,
+    config: serde_json::Value,
+) -> Result<serde_json::Value, String> {
+    let id = uuid::Uuid::new_v4().to_string();
+    let now = chrono::Utc::now().to_rfc3339();
+    let config_str = serde_json::to_string(&config).map_err(|e| e.to_string())?;
+
+    state
+        .db
+        .conn()
+        .execute(
+            "INSERT INTO channels (id, channel_type, name, status, config, created_at) \
+             VALUES (?1, ?2, ?3, 'disconnected', ?4, ?5)",
+            [&id, &channel_type, &name, &config_str, &now],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(serde_json::json!({
+        "id": id,
+        "channel_type": channel_type,
+        "name": name,
+        "status": "disconnected",
+        "config": config_str,
+        "created_at": now,
+    }))
+}
+
+#[tauri::command]
+pub async fn remove_channel(
+    state: State<'_, AppState>,
+    channel_id: String,
+) -> Result<(), String> {
+    state
+        .db
+        .conn()
+        .execute("DELETE FROM channels WHERE id = ?1", [&channel_id])
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn connect_channel(
+    state: State<'_, AppState>,
+    channel_id: String,
+) -> Result<(), String> {
+    state
+        .db
+        .conn()
+        .execute(
+            "UPDATE channels SET status = 'connecting' WHERE id = ?1",
+            [&channel_id],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+    // Actual connection logic would be handled by a background task.
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn disconnect_channel(
+    state: State<'_, AppState>,
+    channel_id: String,
+) -> Result<(), String> {
+    state
+        .db
+        .conn()
+        .execute(
+            "UPDATE channels SET status = 'disconnected' WHERE id = ?1",
+            [&channel_id],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(())
+}

package/template/src-tauri/src/commands/events.rs

@@ -0,0 +1,43 @@
+use keel_tauri::state::AppState;
+use tauri::State;
+
+/// List recent events from the event log table.
+/// Falls back to an empty list if the table does not yet exist.
+#[tauri::command]
+pub async fn list_events(
+    state: State<'_, AppState>,
+    project_id: String,
+) -> Result<Vec<serde_json::Value>, String> {
+    let rows = state
+        .db
+        .conn()
+        .query(
+            "SELECT id, input_type, source_channel, source_identifier, \
+                    payload, project_id, created_at \
+             FROM event_log WHERE project_id = ?1 \
+             ORDER BY created_at DESC LIMIT 100",
+            [project_id],
+        )
+        .await;
+
+    match rows {
+        Ok(mut rows) => {
+            let mut results = Vec::new();
+            while let Ok(Some(row)) = rows.next().await {
+                let entry = serde_json::json!({
+                    "id": row.get::<String>(0).unwrap_or_default(),
+                    "input_type": row.get::<String>(1).unwrap_or_default(),
+                    "source_channel": row.get::<String>(2).unwrap_or_default(),
+                    "source_identifier": row.get::<String>(3).unwrap_or_default(),
+                    "payload": row.get::<String>(4).unwrap_or_default(),
+                    "project_id": row.get::<String>(5).unwrap_or_default(),
+                    "created_at": row.get::<String>(6).unwrap_or_default(),
+                });
+                results.push(entry);
+            }
+            Ok(results)
+        }
+        // Table may not exist yet in fresh databases.
+        Err(_) => Ok(Vec::new()),
+    }
+}

package/template/src-tauri/src/commands/issues.rs

@@ -0,0 +1,29 @@
+use keel_tauri::keel_db::Issue;
+use keel_tauri::state::AppState;
+use tauri::State;
+
+#[tauri::command]
+pub async fn list_issues(
+    state: State<'_, AppState>,
+    project_id: String,
+) -> Result<Vec<Issue>, String> {
+    state
+        .db
+        .list_issues(&project_id)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn create_issue(
+    state: State<'_, AppState>,
+    project_id: String,
+    title: String,
+    description: String,
+) -> Result<Issue, String> {
+    state
+        .db
+        .create_issue(&project_id, &title, &description, None)
+        .await
+        .map_err(|e| e.to_string())
+}

package/template/src-tauri/src/commands/memory.rs

@@ -0,0 +1,52 @@
+use keel_tauri::keel_memory::{Memory, MemoryCategory, MemoryQuery, MemoryStore};
+use tauri::State;
+
+#[tauri::command]
+pub async fn list_memories(
+    store: State<'_, MemoryStore>,
+    project_id: String,
+) -> Result<Vec<Memory>, String> {
+    store
+        .list_by_project(&project_id)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn create_memory(
+    store: State<'_, MemoryStore>,
+    project_id: String,
+    content: String,
+    category: String,
+    tags: Vec<String>,
+) -> Result<Memory, String> {
+    let cat: MemoryCategory = category.parse().map_err(|e: anyhow::Error| e.to_string())?;
+    store
+        .create(&project_id, &content, cat, "user", tags)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn delete_memory(
+    store: State<'_, MemoryStore>,
+    memory_id: String,
+) -> Result<(), String> {
+    store.delete(&memory_id).await.map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn search_memories(
+    store: State<'_, MemoryStore>,
+    project_id: String,
+    query: String,
+) -> Result<Vec<Memory>, String> {
+    store
+        .search(MemoryQuery {
+            project_id: Some(project_id),
+            search_text: Some(query),
+            ..Default::default()
+        })
+        .await
+        .map_err(|e| e.to_string())
+}

package/template/src-tauri/src/commands/mod.rs

@@ -0,0 +1,8 @@
+pub mod channels;
+pub mod events;
+pub mod issues;
+pub mod memory;
+pub mod projects;
+pub mod scheduler;
+pub mod sessions;
+pub mod workspace;

package/template/src-tauri/src/commands/projects.rs

@@ -0,0 +1,38 @@
+use crate::workspace;
+use keel_tauri::keel_db::Project;
+use keel_tauri::state::AppState;
+use tauri::State;
+
+#[tauri::command]
+pub async fn list_projects(state: State<'_, AppState>) -> Result<Vec<Project>, String> {
+    state.db.list_projects().await.map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn create_project(
+    state: State<'_, AppState>,
+    name: String,
+    folder_path: String,
+) -> Result<Project, String> {
+    // Seed workspace files (CLAUDE.md, etc.)
+    workspace::seed_workspace(&folder_path);
+
+    state
+        .db
+        .create_project(&name, &folder_path)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn delete_project(
+    state: State<'_, AppState>,
+    project_id: String,
+) -> Result<(), String> {
+    // Only removes from DB — does NOT delete the folder on disk.
+    state
+        .db
+        .delete_project(&project_id)
+        .await
+        .map_err(|e| e.to_string())
+}

package/template/src-tauri/src/commands/scheduler.rs

@@ -0,0 +1,67 @@
+use keel_tauri::state::AppState;
+use tauri::State;
+
+#[tauri::command]
+pub async fn add_heartbeat(
+    state: State<'_, AppState>,
+    config: serde_json::Value,
+) -> Result<String, String> {
+    let scheduler = state
+        .scheduler
+        .as_ref()
+        .ok_or_else(|| "Scheduler not initialized".to_string())?;
+
+    let hb_config: keel_scheduler::HeartbeatConfig =
+        serde_json::from_value(config).map_err(|e| e.to_string())?;
+
+    let mut sched = scheduler.lock().await;
+    let id = sched.add_heartbeat(hb_config);
+    Ok(id)
+}
+
+#[tauri::command]
+pub async fn remove_heartbeat(
+    state: State<'_, AppState>,
+    id: String,
+) -> Result<(), String> {
+    let scheduler = state
+        .scheduler
+        .as_ref()
+        .ok_or_else(|| "Scheduler not initialized".to_string())?;
+
+    let mut sched = scheduler.lock().await;
+    sched.remove_heartbeat(&id);
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn add_cron(
+    state: State<'_, AppState>,
+    config: serde_json::Value,
+) -> Result<String, String> {
+    let scheduler = state
+        .scheduler
+        .as_ref()
+        .ok_or_else(|| "Scheduler not initialized".to_string())?;
+
+    let cron_config: keel_scheduler::CronJobConfig =
+        serde_json::from_value(config).map_err(|e| e.to_string())?;
+
+    let mut sched = scheduler.lock().await;
+    sched.add_cron(cron_config).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn remove_cron(
+    state: State<'_, AppState>,
+    id: String,
+) -> Result<(), String> {
+    let scheduler = state
+        .scheduler
+        .as_ref()
+        .ok_or_else(|| "Scheduler not initialized".to_string())?;
+
+    let mut sched = scheduler.lock().await;
+    sched.remove_cron(&id);
+    Ok(())
+}

package/template/src-tauri/src/commands/sessions.rs

@@ -0,0 +1,80 @@
+use crate::workspace;
+use keel_tauri::chat_session::ChatSessionState;
+use keel_tauri::paths::expand_tilde;
+use keel_tauri::session_runner::{spawn_and_monitor, PersistOptions};
+use keel_tauri::state::AppState;
+use tauri::State;
+
+#[tauri::command]
+pub async fn start_session(
+    app_handle: tauri::AppHandle,
+    state: State<'_, AppState>,
+    chat_state: State<'_, ChatSessionState>,
+    project_id: String,
+    prompt: String,
+) -> Result<String, String> {
+    let project = state
+        .db
+        .get_project(&project_id)
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "Project not found".to_string())?;
+
+    let working_dir = expand_tilde(&project.folder_path);
+
+    // Seed workspace files on first use.
+    workspace::seed_workspace(&project.folder_path);
+
+    // Build system prompt from CLAUDE.md if it exists.
+    let system_prompt = {
+        let claude_md = working_dir.join("CLAUDE.md");
+        if claude_md.exists() {
+            std::fs::read_to_string(&claude_md).ok()
+        } else {
+            None
+        }
+    };
+
+    // Resume previous session if we have one.
+    let resume_id = chat_state.get();
+
+    let session_key = "main".to_string();
+
+    let _handle = spawn_and_monitor(
+        &app_handle,
+        &session_key,
+        &prompt,
+        resume_id.as_deref(),
+        Some(working_dir),
+        system_prompt.as_deref(),
+        Some(chat_state.inner().clone()),
+        Some(PersistOptions {
+            db: state.db.clone(),
+            project_id: project_id.clone(),
+            feed_key: session_key.clone(),
+            source: "desktop".to_string(),
+        }),
+    );
+
+    Ok(session_key)
+}
+
+#[tauri::command]
+pub async fn load_chat_feed(
+    state: State<'_, AppState>,
+    project_id: String,
+    feed_key: String,
+) -> Result<Vec<serde_json::Value>, String> {
+    let rows = state
+        .db
+        .list_chat_feed(&project_id, &feed_key)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let items: Vec<serde_json::Value> = rows
+        .into_iter()
+        .filter_map(|row| serde_json::from_str(&row.data_json).ok())
+        .collect();
+
+    Ok(items)
+}