claudit 0.1.0

package/server/dist/server/src/services/todoStorage.js

@@ -0,0 +1,112 @@
+import crypto from 'crypto';
+import { db } from './database.js';
+// --- Prepared statements ---
+const stmtAll = db.prepare('SELECT * FROM todos ORDER BY position ASC, createdAt ASC');
+const stmtById = db.prepare('SELECT * FROM todos WHERE id = ?');
+const stmtInsert = db.prepare(`
+  INSERT INTO todos (id, title, description, completed, priority, sessionId, sessionLabel, groupId, position, createdAt, completedAt,
+    providerId, configId, externalId, externalUrl, lastSyncedAt, syncStatus, syncError)
+  VALUES (@id, @title, @description, @completed, @priority, @sessionId, @sessionLabel, @groupId, @position, @createdAt, @completedAt,
+    @providerId, @configId, @externalId, @externalUrl, @lastSyncedAt, @syncStatus, @syncError)
+`);
+const stmtDelete = db.prepare('DELETE FROM todos WHERE id = ?');
+const stmtMaxPosition = db.prepare('SELECT COALESCE(MAX(position), 0) as maxPos FROM todos WHERE groupId IS ?');
+const stmtUpdatePositionGroup = db.prepare('UPDATE todos SET position = ?, groupId = ? WHERE id = ?');
+function rowToTodo(row) {
+    const todo = {
+        id: row.id,
+        title: row.title,
+        completed: row.completed === 1,
+        priority: row.priority,
+        position: row.position ?? 0,
+        createdAt: row.createdAt,
+    };
+    if (row.description != null)
+        todo.description = row.description;
+    if (row.sessionId != null)
+        todo.sessionId = row.sessionId;
+    if (row.sessionLabel != null)
+        todo.sessionLabel = row.sessionLabel;
+    if (row.groupId != null)
+        todo.groupId = row.groupId;
+    if (row.completedAt != null)
+        todo.completedAt = row.completedAt;
+    if (row.providerId != null) {
+        todo.provider = {
+            providerId: row.providerId,
+            configId: row.configId,
+            externalId: row.externalId,
+            externalUrl: row.externalUrl,
+            lastSyncedAt: row.lastSyncedAt,
+            syncStatus: row.syncStatus,
+            syncError: row.syncError,
+        };
+    }
+    return todo;
+}
+function todoToParams(todo) {
+    const p = todo.provider;
+    return {
+        id: todo.id,
+        title: todo.title,
+        description: todo.description ?? null,
+        completed: todo.completed ? 1 : 0,
+        priority: todo.priority,
+        sessionId: todo.sessionId ?? null,
+        sessionLabel: todo.sessionLabel ?? null,
+        groupId: todo.groupId ?? null,
+        position: todo.position ?? 0,
+        createdAt: todo.createdAt,
+        completedAt: todo.completedAt ?? null,
+        providerId: p?.providerId ?? null,
+        configId: p?.configId ?? null,
+        externalId: p?.externalId ?? null,
+        externalUrl: p?.externalUrl ?? null,
+        lastSyncedAt: p?.lastSyncedAt ?? null,
+        syncStatus: p?.syncStatus ?? null,
+        syncError: p?.syncError ?? null,
+    };
+}
+export function getNextPosition(groupId) {
+    const row = stmtMaxPosition.get(groupId ?? null);
+    return (row?.maxPos ?? 0) + 1000;
+}
+export function getAllTodos() {
+    return stmtAll.all().map(rowToTodo);
+}
+export function getTodo(id) {
+    const row = stmtById.get(id);
+    return row ? rowToTodo(row) : undefined;
+}
+export function createTodo(data) {
+    const todo = {
+        ...data,
+        id: crypto.randomUUID(),
+        createdAt: new Date().toISOString(),
+        position: data.position ?? getNextPosition(data.groupId),
+    };
+    stmtInsert.run(todoToParams(todo));
+    return todo;
+}
+export function updateTodo(id, updates) {
+    const existing = getTodo(id);
+    if (!existing)
+        return null;
+    const merged = { ...existing, ...updates, id };
+    // Delete and re-insert (simple, keeps same prepared stmt)
+    stmtDelete.run(id);
+    stmtInsert.run(todoToParams(merged));
+    return merged;
+}
+export function deleteTodo(id) {
+    const result = stmtDelete.run(id);
+    return result.changes > 0;
+}
+export function reorderTodos(items) {
+    const txn = db.transaction(() => {
+        for (const item of items) {
+            stmtUpdatePositionGroup.run(item.position, item.groupId ?? null, item.id);
+        }
+    });
+    txn();
+}

package/server/dist/server/src/services/todoSyncEngine.js

@@ -0,0 +1,170 @@
+import { getProvider } from './providers/registry.js';
+import { getAllConfigs, getConfig, updateConfig } from './providerConfigStorage.js';
+import { getAllTodos, createTodo, updateTodo } from './todoStorage.js';
+/**
+ * Sync a single provider config: fetch external items and upsert into local todos.
+ */
+export async function syncProvider(config) {
+    const result = {
+        configId: config.id,
+        imported: 0,
+        updated: 0,
+        errors: [],
+    };
+    const provider = getProvider(config.providerId);
+    if (!provider) {
+        result.errors.push(`Provider "${config.providerId}" not found`);
+        updateConfig(config.id, { lastSyncError: result.errors[0] });
+        return result;
+    }
+    try {
+        const externalItems = await provider.fetchItems(config.config);
+        const localTodos = getAllTodos();
+        // Index existing provider-linked todos by externalId for this config
+        const localByExternalId = new Map();
+        for (const todo of localTodos) {
+            if (todo.provider?.configId === config.id && todo.provider.externalId) {
+                localByExternalId.set(todo.provider.externalId, todo);
+            }
+        }
+        for (const ext of externalItems) {
+            try {
+                const existing = localByExternalId.get(ext.externalId);
+                if (existing) {
+                    // Update if changed
+                    const needsUpdate = existing.title !== ext.title ||
+                        existing.description !== ext.description ||
+                        existing.completed !== ext.completed ||
+                        existing.priority !== ext.priority;
+                    if (needsUpdate && existing.provider?.syncStatus !== 'local_modified') {
+                        updateTodo(existing.id, {
+                            title: ext.title,
+                            description: ext.description,
+                            completed: ext.completed,
+                            completedAt: ext.completed && !existing.completedAt
+                                ? new Date().toISOString()
+                                : existing.completedAt,
+                            priority: ext.priority,
+                            provider: {
+                                ...existing.provider,
+                                lastSyncedAt: new Date().toISOString(),
+                                syncStatus: 'synced',
+                                syncError: undefined,
+                            },
+                        });
+                        result.updated++;
+                    }
+                }
+                else {
+                    // Create new
+                    createTodo({
+                        title: ext.title,
+                        description: ext.description,
+                        completed: ext.completed,
+                        completedAt: ext.completed ? new Date().toISOString() : undefined,
+                        priority: ext.priority,
+                        position: 0,
+                        provider: {
+                            providerId: config.providerId,
+                            configId: config.id,
+                            externalId: ext.externalId,
+                            externalUrl: ext.externalUrl,
+                            lastSyncedAt: new Date().toISOString(),
+                            syncStatus: 'synced',
+                        },
+                    });
+                    result.imported++;
+                }
+            }
+            catch (err) {
+                result.errors.push(`Item ${ext.externalId}: ${err.message}`);
+            }
+        }
+        updateConfig(config.id, {
+            lastSyncAt: new Date().toISOString(),
+            lastSyncError: result.errors.length > 0 ? result.errors.join('; ') : undefined,
+        });
+    }
+    catch (err) {
+        const errMsg = `Sync failed: ${err.message}`;
+        result.errors.push(errMsg);
+        updateConfig(config.id, { lastSyncError: errMsg });
+    }
+    return result;
+}
+/**
+ * When a provider-linked todo is completed locally, push completion to external system.
+ */
+export async function pushCompletion(todo) {
+    if (!todo.provider)
+        return;
+    const config = getConfig(todo.provider.configId);
+    if (!config)
+        return;
+    const provider = getProvider(todo.provider.providerId);
+    if (!provider?.completeItem)
+        return;
+    try {
+        await provider.completeItem(config.config, todo.provider.externalId);
+        updateTodo(todo.id, {
+            provider: {
+                ...todo.provider,
+                lastSyncedAt: new Date().toISOString(),
+                syncStatus: 'synced',
+            },
+        });
+    }
+    catch (err) {
+        updateTodo(todo.id, {
+            provider: {
+                ...todo.provider,
+                syncStatus: 'sync_error',
+                syncError: err.message,
+            },
+        });
+    }
+}
+/**
+ * Sync all enabled provider configs.
+ */
+export async function syncAllProviders() {
+    const configs = getAllConfigs().filter(c => c.enabled);
+    const results = [];
+    for (const config of configs) {
+        const result = await syncProvider(config);
+        results.push(result);
+    }
+    return results;
+}
+let syncInterval = null;
+/**
+ * Initialize periodic sync. Checks every 60s if any config needs syncing.
+ */
+export function initProviderSync() {
+    if (syncInterval)
+        return;
+    syncInterval = setInterval(async () => {
+        const configs = getAllConfigs().filter(c => c.enabled && c.syncIntervalMinutes && c.syncIntervalMinutes > 0);
+        for (const config of configs) {
+            const intervalMs = config.syncIntervalMinutes * 60 * 1000;
+            const lastSync = config.lastSyncAt ? new Date(config.lastSyncAt).getTime() : 0;
+            if (Date.now() - lastSync >= intervalMs) {
+                try {
+                    await syncProvider(config);
+                }
+                catch (err) {
+                    console.error(`Auto-sync failed for config "${config.name}":`, err);
+                }
+            }
+        }
+    }, 60_000);
+}
+/**
+ * Stop periodic sync.
+ */
+export function stopProviderSync() {
+    if (syncInterval) {
+        clearInterval(syncInterval);
+        syncInterval = null;
+    }
+}

package/server/dist/server/src/types.js

@@ -0,0 +1 @@
+export {};

package/server/dist/shared/src/index.js

@@ -0,0 +1 @@
+export {};

package/server/dist/shared/src/types.js

@@ -0,0 +1,2 @@
+// --- History Index Types ---
+export {};