floq 0.0.1 → 0.2.0

package/dist/commands/add.js

@@ -8,16 +8,15 @@ export async function addTask(title, options) {
     const i18n = t();
     let parentId;
     if (options.project) {
-        const project = db
+        const projects = await db
             .select()
             .from(schema.tasks)
-            .where(and(eq(schema.tasks.isProject, true), eq(schema.tasks.title, options.project)))
-            .get();
-        if (!project) {
+            .where(and(eq(schema.tasks.isProject, true), eq(schema.tasks.title, options.project)));
+        if (projects.length === 0) {
             console.error(fmt(i18n.commands.add.projectNotFound, { project: options.project }));
             process.exit(1);
         }
-        parentId = project.id;
+        parentId = projects[0].id;
     }
     const task = {
         id: uuidv4(),
@@ -28,7 +27,7 @@ export async function addTask(title, options) {
         createdAt: now,
         updatedAt: now,
     };
-    db.insert(schema.tasks).values(task).run();
+    await db.insert(schema.tasks).values(task);
     console.log(fmt(i18n.commands.add.success, { title }));
     if (parentId) {
         console.log(fmt(i18n.commands.add.withProject, { project: options.project }));

package/dist/commands/comment.d.ts

@@ -0,0 +1,2 @@
+export declare function addComment(taskId: string, content: string): Promise<void>;
+export declare function listComments(taskId: string): Promise<void>;

package/dist/commands/comment.js

@@ -0,0 +1,67 @@
+import { eq, like } from 'drizzle-orm';
+import { v4 as uuidv4 } from 'uuid';
+import { getDb, schema } from '../db/index.js';
+import { t, fmt } from '../i18n/index.js';
+export async function addComment(taskId, content) {
+    const db = getDb();
+    const i18n = t();
+    // Find task by ID prefix
+    const tasks = await db
+        .select()
+        .from(schema.tasks)
+        .where(like(schema.tasks.id, `${taskId}%`));
+    if (tasks.length === 0) {
+        console.error(fmt(i18n.commands.comment.notFound, { id: taskId }));
+        process.exit(1);
+    }
+    if (tasks.length > 1) {
+        console.error(fmt(i18n.commands.comment.multipleMatch, { id: taskId }));
+        for (const task of tasks) {
+            console.error(`  [${task.id.slice(0, 8)}] ${task.title}`);
+        }
+        process.exit(1);
+    }
+    const task = tasks[0];
+    await db.insert(schema.comments).values({
+        id: uuidv4(),
+        taskId: task.id,
+        content: content.trim(),
+        createdAt: new Date(),
+    });
+    console.log(fmt(i18n.commands.comment.added, { title: task.title }));
+}
+export async function listComments(taskId) {
+    const db = getDb();
+    const i18n = t();
+    // Find task by ID prefix
+    const tasks = await db
+        .select()
+        .from(schema.tasks)
+        .where(like(schema.tasks.id, `${taskId}%`));
+    if (tasks.length === 0) {
+        console.error(fmt(i18n.commands.comment.notFound, { id: taskId }));
+        process.exit(1);
+    }
+    if (tasks.length > 1) {
+        console.error(fmt(i18n.commands.comment.multipleMatch, { id: taskId }));
+        for (const task of tasks) {
+            console.error(`  [${task.id.slice(0, 8)}] ${task.title}`);
+        }
+        process.exit(1);
+    }
+    const task = tasks[0];
+    const comments = await db
+        .select()
+        .from(schema.comments)
+        .where(eq(schema.comments.taskId, task.id));
+    if (comments.length === 0) {
+        console.log(fmt(i18n.commands.comment.listHeader, { title: task.title }));
+        console.log(`  ${i18n.commands.comment.noComments}`);
+        return;
+    }
+    console.log(fmt(i18n.commands.comment.listHeader, { title: task.title }));
+    for (const comment of comments) {
+        const date = comment.createdAt.toLocaleString();
+        console.log(`  [${date}] ${comment.content}`);
+    }
+}

package/dist/commands/config.d.ts

@@ -4,3 +4,10 @@ export declare function setDbPath(dbPath: string): Promise<void>;
 export declare function resetDbPath(): Promise<void>;
 export declare function setTheme(theme: string): Promise<void>;
 export declare function selectTheme(): Promise<void>;
+export declare function showViewMode(): Promise<void>;
+export declare function setViewModeCommand(mode: string): Promise<void>;
+export declare function selectMode(): Promise<void>;
+export declare function setTurso(url: string, token: string): Promise<void>;
+export declare function disableTurso(): Promise<void>;
+export declare function syncCommand(): Promise<void>;
+export declare function resetDatabase(force: boolean): Promise<void>;

package/dist/commands/config.js

@@ -1,10 +1,16 @@
 import { render } from 'ink';
 import React from 'react';
-import { loadConfig, saveConfig, getDbPath } from '../config.js';
+import { createInterface } from 'readline';
+import { unlinkSync, existsSync, readdirSync } from 'fs';
+import { dirname, basename, join } from 'path';
+import { loadConfig, saveConfig, getDbPath, getViewMode, setViewMode, isTursoEnabled, getTursoConfig, setTursoConfig } from '../config.js';
 import { CONFIG_FILE } from '../paths.js';
 import { ThemeSelector } from '../ui/ThemeSelector.js';
+import { ModeSelector } from '../ui/ModeSelector.js';
+import { syncDb } from '../db/index.js';
+import { VALID_THEMES, themes } from '../ui/theme/themes.js';
 const VALID_LOCALES = ['en', 'ja'];
-const VALID_THEMES = ['modern', 'norton-commander', 'dos-prompt', 'turbo-pascal'];
+const VALID_VIEW_MODES = ['gtd', 'kanban'];
 export async function showConfig() {
     const config = loadConfig();
     console.log('GTD CLI Configuration');
@@ -13,9 +19,14 @@ export async function showConfig() {
     console.log(`Language: ${config.locale}`);
     console.log(`Database: ${getDbPath()}`);
     console.log(`Theme: ${config.theme || 'modern'}`);
+    console.log(`View Mode: ${config.viewMode || 'gtd'}`);
+    console.log(`Turso: ${isTursoEnabled() ? 'enabled' : 'disabled'}`);
     if (config.db_path) {
         console.log(`  (custom: ${config.db_path})`);
     }
+    if (config.turso) {
+        console.log(`  URL: ${config.turso.url}`);
+    }
 }
 export async function setLanguage(locale) {
     if (!VALID_LOCALES.includes(locale)) {
@@ -45,13 +56,8 @@ export async function setTheme(theme) {
         process.exit(1);
     }
     saveConfig({ theme: theme });
-    const messages = {
-        'modern': 'Theme set to Modern',
-        'norton-commander': 'Theme set to Norton Commander (MS-DOS style)',
-        'dos-prompt': 'Theme set to DOS Prompt (green on black)',
-        'turbo-pascal': 'Theme set to Turbo Pascal IDE',
-    };
-    console.log(messages[theme]);
+    const themeData = themes[theme];
+    console.log(`Theme set to ${themeData.displayName}`);
 }
 export async function selectTheme() {
     return new Promise((resolve) => {
@@ -59,15 +65,158 @@ export async function selectTheme() {
             onSelect: (theme) => {
                 unmount();
                 saveConfig({ theme });
+                const themeData = themes[theme];
+                console.log(`Theme set to ${themeData.displayName}`);
+                resolve();
+            },
+        }));
+    });
+}
+export async function showViewMode() {
+    const mode = getViewMode();
+    console.log(`Current view mode: ${mode}`);
+}
+export async function setViewModeCommand(mode) {
+    if (!VALID_VIEW_MODES.includes(mode)) {
+        console.error(`Invalid view mode: ${mode}`);
+        console.error(`Valid modes: ${VALID_VIEW_MODES.join(', ')}`);
+        process.exit(1);
+    }
+    setViewMode(mode);
+    const messages = {
+        gtd: 'View mode set to GTD',
+        kanban: 'View mode set to Kanban',
+    };
+    console.log(messages[mode]);
+}
+export async function selectMode() {
+    return new Promise((resolve) => {
+        const { unmount } = render(React.createElement(ModeSelector, {
+            onSelect: (mode) => {
+                unmount();
+                setViewMode(mode);
                 const messages = {
-                    'modern': 'Theme set to Modern',
-                    'norton-commander': 'Theme set to Norton Commander (MS-DOS style)',
-                    'dos-prompt': 'Theme set to DOS Prompt (green on black)',
-                    'turbo-pascal': 'Theme set to Turbo Pascal IDE',
+                    gtd: 'View mode set to GTD',
+                    kanban: 'View mode set to Kanban',
                 };
-                console.log(messages[theme]);
+                console.log(messages[mode]);
                 resolve();
             },
         }));
     });
 }
+export async function setTurso(url, token) {
+    setTursoConfig({ url, authToken: token });
+    console.log('Turso sync enabled');
+    console.log(`  URL: ${url}`);
+    console.log('Run "floq sync" to sync with Turso cloud');
+}
+export async function disableTurso() {
+    setTursoConfig(undefined);
+    console.log('Turso sync disabled');
+}
+export async function syncCommand() {
+    if (!isTursoEnabled()) {
+        console.error('Turso sync is not enabled.');
+        console.error('Use "floq config turso --url <url> --token <token>" to enable.');
+        process.exit(1);
+    }
+    console.log('Syncing with Turso cloud...');
+    try {
+        await syncDb();
+        console.log('Sync complete');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Sync failed: ${message}`);
+        console.error('');
+        console.error('Possible solutions:');
+        console.error('  1. Check your Turso URL and auth token');
+        console.error('  2. Verify network connectivity');
+        console.error('  3. Try again later');
+        process.exit(1);
+    }
+}
+async function confirm(message) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${message} (y/N): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+async function clearTursoData() {
+    const turso = getTursoConfig();
+    if (!turso)
+        return;
+    const { createClient } = await import('@libsql/client');
+    const client = createClient({
+        url: turso.url,
+        authToken: turso.authToken,
+    });
+    try {
+        await client.execute('DELETE FROM comments');
+        await client.execute('DELETE FROM tasks');
+        console.log('Turso cloud data cleared.');
+    }
+    finally {
+        client.close();
+    }
+}
+export async function resetDatabase(force) {
+    const dbPath = getDbPath();
+    const dbDir = dirname(dbPath);
+    const dbName = basename(dbPath, '.db');
+    const tursoEnabled = isTursoEnabled();
+    // Find all related database files
+    const relatedFiles = [];
+    if (existsSync(dbDir)) {
+        const files = readdirSync(dbDir);
+        for (const file of files) {
+            // Match: floq.db, floq.db-wal, floq.db-shm, floq-turso.db-info, etc.
+            if (file.startsWith(dbName)) {
+                relatedFiles.push(join(dbDir, file));
+            }
+        }
+    }
+    if (relatedFiles.length === 0 && !tursoEnabled) {
+        console.log('Database files do not exist.');
+        return;
+    }
+    if (!force) {
+        if (relatedFiles.length > 0) {
+            console.log('This will delete the following local files:');
+            for (const file of relatedFiles) {
+                console.log(`  ${file}`);
+            }
+        }
+        if (tursoEnabled) {
+            console.log('This will also delete all data in Turso cloud.');
+        }
+        const confirmed = await confirm('Are you sure?');
+        if (!confirmed) {
+            console.log('Cancelled.');
+            return;
+        }
+    }
+    try {
+        // Clear Turso cloud data first
+        if (tursoEnabled) {
+            await clearTursoData();
+        }
+        // Delete local files
+        for (const file of relatedFiles) {
+            unlinkSync(file);
+        }
+        console.log('Database reset complete.');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to reset database: ${message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/done.js

@@ -5,11 +5,10 @@ export async function markDone(taskId) {
     const db = getDb();
     const i18n = t();
     // Find task by ID prefix
-    const tasks = db
+    const tasks = await db
         .select()
         .from(schema.tasks)
-        .where(like(schema.tasks.id, `${taskId}%`))
-        .all();
+        .where(like(schema.tasks.id, `${taskId}%`));
     if (tasks.length === 0) {
         console.error(fmt(i18n.commands.done.notFound, { id: taskId }));
         process.exit(1);
@@ -26,12 +25,11 @@ export async function markDone(taskId) {
         console.log(fmt(i18n.commands.done.alreadyDone, { title: task.title }));
         return;
     }
-    db.update(schema.tasks)
+    await db.update(schema.tasks)
         .set({
         status: 'done',
         updatedAt: new Date(),
     })
-        .where(eq(schema.tasks.id, task.id))
-        .run();
+        .where(eq(schema.tasks.id, task.id));
     console.log(fmt(i18n.commands.done.success, { title: task.title }));
 }

package/dist/commands/list.js

@@ -11,11 +11,10 @@ export async function listTasks(status) {
             console.error(fmt(i18n.commands.list.validStatuses, { statuses: validStatuses.join(', ') }));
             process.exit(1);
         }
-        const tasks = db
+        const tasks = await db
             .select()
             .from(schema.tasks)
-            .where(eq(schema.tasks.status, status))
-            .all();
+            .where(eq(schema.tasks.status, status));
         console.log(`\n${i18n.status[status]} (${tasks.length})`);
         console.log('─'.repeat(40));
         if (tasks.length === 0) {
@@ -40,11 +39,10 @@ export async function listTasks(status) {
     // Show all lists
     const statuses = ['inbox', 'next', 'waiting', 'someday'];
     for (const s of statuses) {
-        const tasks = db
+        const tasks = await db
             .select()
             .from(schema.tasks)
-            .where(eq(schema.tasks.status, s))
-            .all();
+            .where(eq(schema.tasks.status, s));
         console.log(`\n${i18n.status[s]} (${tasks.length})`);
         console.log('─'.repeat(40));
         if (tasks.length === 0) {
@@ -66,12 +64,11 @@ export async function listTasks(status) {
 export async function listProjects() {
     const db = getDb();
     const i18n = t();
-    const projects = db
+    const allProjects = await db
         .select()
         .from(schema.tasks)
-        .where(eq(schema.tasks.isProject, true))
-        .all()
-        .filter(p => p.status !== 'done');
+        .where(eq(schema.tasks.isProject, true));
+    const projects = allProjects.filter(p => p.status !== 'done');
     console.log(`\n${i18n.projectStatus.active} (${projects.length})`);
     console.log('─'.repeat(40));
     if (projects.length === 0) {
@@ -79,11 +76,10 @@ export async function listProjects() {
     }
     else {
         for (const project of projects) {
-            const childTasks = db
+            const childTasks = await db
                 .select()
                 .from(schema.tasks)
-                .where(eq(schema.tasks.parentId, project.id))
-                .all();
+                .where(eq(schema.tasks.parentId, project.id));
             const activeTasks = childTasks.filter(t => t.status !== 'done').length;
             const shortId = project.id.slice(0, 8);
             console.log(`  [${shortId}] ${project.title} (${fmt(i18n.commands.list.tasks, { count: activeTasks })})`);

package/dist/commands/move.js

@@ -15,11 +15,10 @@ export async function moveTask(taskId, targetStatus, waitingFor) {
         process.exit(1);
     }
     // Find task by ID prefix
-    const tasks = db
+    const tasks = await db
         .select()
         .from(schema.tasks)
-        .where(like(schema.tasks.id, `${taskId}%`))
-        .all();
+        .where(like(schema.tasks.id, `${taskId}%`));
     if (tasks.length === 0) {
         console.error(fmt(i18n.commands.move.notFound, { id: taskId }));
         process.exit(1);
@@ -32,14 +31,13 @@ export async function moveTask(taskId, targetStatus, waitingFor) {
         process.exit(1);
     }
     const task = tasks[0];
-    db.update(schema.tasks)
+    await db.update(schema.tasks)
         .set({
         status: targetStatus,
         waitingFor: targetStatus === 'waiting' ? waitingFor : null,
         updatedAt: new Date(),
     })
-        .where(eq(schema.tasks.id, task.id))
-        .run();
+        .where(eq(schema.tasks.id, task.id));
     console.log(fmt(i18n.commands.move.success, {
         title: task.title,
         status: i18n.status[targetStatus]

package/dist/commands/project.js

@@ -7,12 +7,11 @@ export async function addProject(name, options) {
     const now = new Date();
     const i18n = t();
     // Check if project already exists
-    const existing = db
+    const existingProjects = await db
         .select()
         .from(schema.tasks)
-        .where(and(eq(schema.tasks.title, name), eq(schema.tasks.isProject, true)))
-        .get();
-    if (existing) {
+        .where(and(eq(schema.tasks.title, name), eq(schema.tasks.isProject, true)));
+    if (existingProjects.length > 0) {
         console.error(fmt(i18n.commands.project.alreadyExists, { name }));
         process.exit(1);
     }
@@ -25,7 +24,7 @@ export async function addProject(name, options) {
         createdAt: now,
         updatedAt: now,
     };
-    db.insert(schema.tasks).values(project).run();
+    await db.insert(schema.tasks).values(project);
     console.log(fmt(i18n.commands.project.created, { name }));
 }
 export async function listProjectsCommand() {
@@ -38,11 +37,10 @@ export async function listProjectsCommand() {
         done: i18n.projectStatus.completed,
     };
     for (const status of statuses) {
-        const projects = db
+        const projects = await db
             .select()
             .from(schema.tasks)
-            .where(and(eq(schema.tasks.isProject, true), eq(schema.tasks.status, status)))
-            .all();
+            .where(and(eq(schema.tasks.isProject, true), eq(schema.tasks.status, status)));
         if (projects.length === 0 && status !== 'next')
             continue;
         console.log(`\n${statusLabels[status]} (${projects.length})`);
@@ -52,11 +50,10 @@ export async function listProjectsCommand() {
         }
         else {
             for (const project of projects) {
-                const childTasks = db
+                const childTasks = await db
                     .select()
                     .from(schema.tasks)
-                    .where(eq(schema.tasks.parentId, project.id))
-                    .all();
+                    .where(eq(schema.tasks.parentId, project.id));
                 const activeTasks = childTasks.filter(t => t.status !== 'done').length;
                 const doneTasks = childTasks.filter(t => t.status === 'done').length;
                 const shortId = project.id.slice(0, 8);
@@ -73,17 +70,15 @@ export async function showProject(projectId) {
     const db = getDb();
     const i18n = t();
     // Find project by ID prefix or name
-    let projects = db
+    let projects = await db
         .select()
         .from(schema.tasks)
-        .where(and(eq(schema.tasks.isProject, true), like(schema.tasks.id, `${projectId}%`)))
-        .all();
+        .where(and(eq(schema.tasks.isProject, true), like(schema.tasks.id, `${projectId}%`)));
     if (projects.length === 0) {
-        projects = db
+        projects = await db
             .select()
             .from(schema.tasks)
-            .where(and(eq(schema.tasks.isProject, true), eq(schema.tasks.title, projectId)))
-            .all();
+            .where(and(eq(schema.tasks.isProject, true), eq(schema.tasks.title, projectId)));
     }
     if (projects.length === 0) {
         console.error(fmt(i18n.commands.project.notFound, { id: projectId }));
@@ -97,11 +92,10 @@ export async function showProject(projectId) {
         process.exit(1);
     }
     const project = projects[0];
-    const childTasks = db
+    const childTasks = await db
         .select()
         .from(schema.tasks)
-        .where(eq(schema.tasks.parentId, project.id))
-        .all();
+        .where(eq(schema.tasks.parentId, project.id));
     console.log(`\nProject: ${project.title}`);
     console.log('─'.repeat(40));
     if (project.description) {
@@ -135,11 +129,10 @@ export async function showProject(projectId) {
 export async function completeProject(projectId) {
     const db = getDb();
     const i18n = t();
-    const projects = db
+    const projects = await db
         .select()
         .from(schema.tasks)
-        .where(and(eq(schema.tasks.isProject, true), like(schema.tasks.id, `${projectId}%`)))
-        .all();
+        .where(and(eq(schema.tasks.isProject, true), like(schema.tasks.id, `${projectId}%`)));
     if (projects.length === 0) {
         console.error(fmt(i18n.commands.project.notFound, { id: projectId }));
         process.exit(1);
@@ -149,12 +142,11 @@ export async function completeProject(projectId) {
         process.exit(1);
     }
     const project = projects[0];
-    db.update(schema.tasks)
+    await db.update(schema.tasks)
         .set({
         status: 'done',
         updatedAt: new Date(),
     })
-        .where(eq(schema.tasks.id, project.id))
-        .run();
+        .where(eq(schema.tasks.id, project.id));
     console.log(fmt(i18n.commands.project.completed, { name: project.title }));
 }

package/dist/commands/setup.d.ts

@@ -0,0 +1 @@
+export declare function runSetupWizard(): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,13 @@
+import { render } from 'ink';
+import React from 'react';
+import { SetupWizard } from '../ui/SetupWizard.js';
+export async function runSetupWizard() {
+    return new Promise((resolve) => {
+        const { unmount } = render(React.createElement(SetupWizard, {
+            onComplete: () => {
+                unmount();
+                resolve();
+            },
+        }));
+    });
+}

package/dist/config.d.ts

@@ -1,14 +1,28 @@
+import type { ThemeName } from './ui/theme/types.js';
 export type Locale = 'en' | 'ja';
-export type ThemeName = 'modern' | 'norton-commander' | 'dos-prompt' | 'turbo-pascal';
+export type ViewMode = 'gtd' | 'kanban';
+export type { ThemeName };
+export interface TursoConfig {
+    url: string;
+    authToken: string;
+}
 export interface Config {
     locale: Locale;
     db_path?: string;
     theme: ThemeName;
+    viewMode: ViewMode;
+    turso?: TursoConfig;
 }
 export declare function loadConfig(): Config;
 export declare function saveConfig(updates: Partial<Config>): void;
+export declare function getTursoConfig(): TursoConfig | undefined;
+export declare function setTursoConfig(config: TursoConfig | undefined): void;
+export declare function isTursoEnabled(): boolean;
 export declare function getDbPath(): string;
 export declare function getLocale(): Locale;
 export declare function setLocale(locale: Locale): void;
 export declare function getThemeName(): ThemeName;
 export declare function setThemeName(theme: ThemeName): void;
+export declare function getViewMode(): ViewMode;
+export declare function setViewMode(viewMode: ViewMode): void;
+export declare function isFirstRun(): boolean;