create-keel-and-deck-app 0.1.0

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

@@ -0,0 +1,62 @@
+use keel_tauri::paths::expand_tilde;
+use keel_tauri::state::AppState;
+use serde::Serialize;
+use tauri::State;
+
+const KNOWN_FILES: &[(&str, &str)] = &[
+    ("CLAUDE.md", "Agent instructions and behavior rules"),
+];
+
+#[derive(Serialize)]
+pub struct WorkspaceFileInfo {
+    name: String,
+    description: String,
+    exists: bool,
+}
+
+#[tauri::command]
+pub async fn list_workspace_files(
+    state: State<'_, AppState>,
+    project_id: String,
+) -> Result<Vec<WorkspaceFileInfo>, 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 dir = expand_tilde(&project.folder_path);
+    let files = KNOWN_FILES
+        .iter()
+        .map(|(name, desc)| WorkspaceFileInfo {
+            name: name.to_string(),
+            description: desc.to_string(),
+            exists: dir.join(name).exists(),
+        })
+        .collect();
+
+    Ok(files)
+}
+
+#[tauri::command]
+pub async fn read_workspace_file(
+    state: State<'_, AppState>,
+    project_id: String,
+    file_name: 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())?;
+
+    // Only allow reading known files
+    if !KNOWN_FILES.iter().any(|(name, _)| *name == file_name) {
+        return Err(format!("Unknown workspace file: {file_name}"));
+    }
+
+    let path = expand_tilde(&project.folder_path).join(&file_name);
+    std::fs::read_to_string(&path).map_err(|e| format!("Failed to read {file_name}: {e}"))
+}

package/template/src-tauri/src/lib.rs

@@ -0,0 +1,93 @@
+mod commands;
+mod workspace;
+
+use keel_tauri::chat_session::ChatSessionState;
+use keel_tauri::keel_db::Database;
+use keel_tauri::keel_events::EventQueue;
+use keel_tauri::keel_memory::MemoryStore;
+use keel_tauri::keel_scheduler::Scheduler;
+use keel_tauri::state::AppState;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+pub fn run() {
+    tauri::Builder::default()
+        .setup(|app| {
+            let data_dir = keel_tauri::keel_db::db::default_data_dir("{{APP_NAME_SNAKE}}");
+            let db_path = data_dir.join("{{APP_NAME_SNAKE}}.db");
+
+            let db = tauri::async_runtime::block_on(async {
+                Database::connect(&db_path)
+                    .await
+                    .expect("Failed to open database")
+            });
+
+            // Initialize memory store with its own connection to the same DB.
+            let memory_dir = data_dir.join("memories");
+            let memory_store = tauri::async_runtime::block_on(async {
+                let mem_db = libsql::Builder::new_local(&db_path)
+                    .build()
+                    .await
+                    .expect("Failed to open memory DB connection");
+                let mem_conn = Arc::new(
+                    mem_db.connect().expect("Failed to connect for memory store"),
+                );
+                MemoryStore::new_with_markdown_dir(mem_conn, memory_dir)
+                    .await
+                    .expect("Failed to initialize memory store")
+            });
+
+            // Initialize event queue.
+            let (_event_queue, queue_handle) = EventQueue::new();
+
+            // Initialize scheduler with queue handle.
+            let scheduler = Scheduler::new(queue_handle.clone());
+
+            // Chat session state for --resume support.
+            let chat_session = ChatSessionState::default();
+
+            app.manage(AppState {
+                db,
+                event_queue: Some(queue_handle),
+                scheduler: Some(Arc::new(Mutex::new(scheduler))),
+            });
+            app.manage(memory_store);
+            app.manage(chat_session);
+
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            // Projects (agents)
+            commands::projects::list_projects,
+            commands::projects::create_project,
+            // Issues
+            commands::issues::list_issues,
+            commands::issues::create_issue,
+            // Sessions
+            commands::sessions::start_session,
+            commands::sessions::load_chat_feed,
+            // Workspace
+            commands::workspace::list_workspace_files,
+            commands::workspace::read_workspace_file,
+            // Memory
+            commands::memory::list_memories,
+            commands::memory::create_memory,
+            commands::memory::delete_memory,
+            commands::memory::search_memories,
+            // Events
+            commands::events::list_events,
+            // Scheduler
+            commands::scheduler::add_heartbeat,
+            commands::scheduler::remove_heartbeat,
+            commands::scheduler::add_cron,
+            commands::scheduler::remove_cron,
+            // Channels
+            commands::channels::list_channels,
+            commands::channels::add_channel,
+            commands::channels::remove_channel,
+            commands::channels::connect_channel,
+            commands::channels::disconnect_channel,
+        ])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}

package/template/src-tauri/src/main.rs

@@ -0,0 +1,6 @@
+// Prevents additional console window on Windows in release.
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    {{APP_NAME_SNAKE}}_lib::run();
+}

package/template/src-tauri/src/workspace.rs

@@ -0,0 +1,21 @@
+use keel_tauri::paths::expand_tilde;
+use keel_tauri::workspace::seed_file;
+
+const CLAUDE_MD_TEMPLATE: &str = r#"# {{APP_NAME_TITLE}} Agent
+
+## Role
+You are a helpful AI assistant.
+
+## Rules
+- Be concise and direct
+- Ask before making destructive changes
+- Explain your reasoning when making decisions
+"#;
+
+/// Seed workspace files for a new agent. Creates the folder and writes
+/// CLAUDE.md if it doesn't already exist.
+pub fn seed_workspace(folder_path: &str) {
+    let dir = expand_tilde(folder_path);
+    std::fs::create_dir_all(&dir).ok();
+    seed_file(&dir, "CLAUDE.md", CLAUDE_MD_TEMPLATE);
+}

package/template/src-tauri/tauri.conf.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://raw.githubusercontent.com/nickelpack/tauri/v2/crates/tauri-config-schema/schema.json",
+  "productName": "{{APP_NAME_TITLE}}",
+  "identifier": "com.{{APP_NAME_SNAKE}}.app",
+  "build": {
+    "frontendDist": "../dist",
+    "devUrl": "http://localhost:1420",
+    "beforeDevCommand": "pnpm dev",
+    "beforeBuildCommand": "pnpm build"
+  },
+  "app": {
+    "withGlobalTauri": false,
+    "windows": [
+      {
+        "title": "{{APP_NAME_TITLE}}",
+        "width": 1200,
+        "height": 800,
+        "minWidth": 800,
+        "minHeight": 600,
+        "decorations": true,
+        "transparent": false,
+        "titleBarStyle": "Overlay"
+      }
+    ],
+    "security": {
+      "csp": null,
+      "capabilities": ["default"]
+    }
+  }
+}

package/template/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "useDefineForClassFields": true,
+    "lib": ["ES2021", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

package/template/vite.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+
+const host = process.env.TAURI_DEV_HOST;
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  clearScreen: false,
+  server: {
+    port: 1420,
+    strictPort: true,
+    host: host || false,
+    hmr: host ? { protocol: "ws", host, port: 1421 } : undefined,
+    watch: { ignored: ["**/src-tauri/**"] },
+  },
+});