floq 0.1.0 → 0.2.0

package/dist/commands/config.js

@@ -1,11 +1,16 @@
 import { render } from 'ink';
 import React from 'react';
-import { loadConfig, saveConfig, getDbPath, isTursoEnabled, setTursoConfig } 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_VIEW_MODES = ['gtd', 'kanban'];
 export async function showConfig() {
     const config = loadConfig();
     console.log('GTD CLI Configuration');
@@ -14,6 +19,7 @@ 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})`);
@@ -66,6 +72,39 @@ export async function selectTheme() {
         }));
     });
 }
+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 = {
+                    gtd: 'View mode set to GTD',
+                    kanban: 'View mode set to Kanban',
+                };
+                console.log(messages[mode]);
+                resolve();
+            },
+        }));
+    });
+}
 export async function setTurso(url, token) {
     setTursoConfig({ url, authToken: token });
     console.log('Turso sync enabled');
@@ -98,3 +137,86 @@ export async function syncCommand() {
         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/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,5 +1,6 @@
 import type { ThemeName } from './ui/theme/types.js';
 export type Locale = 'en' | 'ja';
+export type ViewMode = 'gtd' | 'kanban';
 export type { ThemeName };
 export interface TursoConfig {
     url: string;
@@ -9,6 +10,7 @@ export interface Config {
     locale: Locale;
     db_path?: string;
     theme: ThemeName;
+    viewMode: ViewMode;
     turso?: TursoConfig;
 }
 export declare function loadConfig(): Config;
@@ -21,3 +23,6 @@ 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;

package/dist/config.js

@@ -1,9 +1,37 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'fs';
 import { dirname, join, isAbsolute } from 'path';
 import { CONFIG_FILE, DATA_DIR } from './paths.js';
+// Migrate legacy DB file names (including related metadata files)
+function migrateDbFiles() {
+    const legacyDb = join(DATA_DIR, 'gtd.db');
+    const newDb = join(DATA_DIR, 'floq.db');
+    const legacyTursoDb = join(DATA_DIR, 'gtd-turso.db');
+    const newTursoDb = join(DATA_DIR, 'floq-turso.db');
+    // Turso/libsql related file suffixes
+    const tursoSuffixes = ['', '-info', '-shm', '-wal'];
+    try {
+        if (existsSync(legacyDb) && !existsSync(newDb)) {
+            renameSync(legacyDb, newDb);
+        }
+        // Migrate Turso DB and all related metadata files
+        for (const suffix of tursoSuffixes) {
+            const legacyFile = legacyTursoDb + suffix;
+            const newFile = newTursoDb + suffix;
+            if (existsSync(legacyFile) && !existsSync(newFile)) {
+                renameSync(legacyFile, newFile);
+            }
+        }
+    }
+    catch {
+        // Ignore migration errors
+    }
+}
+// Run DB file migration on module load
+migrateDbFiles();
 const DEFAULT_CONFIG = {
     locale: 'en',
     theme: 'modern',
+    viewMode: 'gtd',
 };
 let configCache = null;
 export function loadConfig() {
@@ -60,9 +88,9 @@ export function getDbPath() {
     }
     // Turso モードでは別のDBファイルを使用（embedded replica 用）
     if (isTursoEnabled()) {
-        return join(DATA_DIR, 'gtd-turso.db');
+        return join(DATA_DIR, 'floq-turso.db');
     }
-    return join(DATA_DIR, 'gtd.db');
+    return join(DATA_DIR, 'floq.db');
 }
 export function getLocale() {
     return loadConfig().locale;
@@ -76,3 +104,12 @@ export function getThemeName() {
 export function setThemeName(theme) {
     saveConfig({ theme });
 }
+export function getViewMode() {
+    return loadConfig().viewMode || 'gtd';
+}
+export function setViewMode(viewMode) {
+    saveConfig({ viewMode });
+}
+export function isFirstRun() {
+    return !existsSync(CONFIG_FILE);
+}

package/dist/db/index.js

@@ -43,6 +43,16 @@ async function initializeRemoteSchema(tursoUrl, authToken) {
             await remoteClient.execute("CREATE INDEX IF NOT EXISTS idx_tasks_parent_id ON tasks(parent_id)");
             await remoteClient.execute("CREATE INDEX IF NOT EXISTS idx_tasks_is_project ON tasks(is_project)");
         }
+        // Create comments table
+        await remoteClient.execute(`
+      CREATE TABLE IF NOT EXISTS comments (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+        await remoteClient.execute("CREATE INDEX IF NOT EXISTS idx_comments_task_id ON comments(task_id)");
     }
     finally {
         remoteClient.close();
@@ -95,6 +105,16 @@ async function initializeLocalSchema() {
         await client.execute("CREATE INDEX IF NOT EXISTS idx_tasks_parent_id ON tasks(parent_id)");
         await client.execute("CREATE INDEX IF NOT EXISTS idx_tasks_is_project ON tasks(is_project)");
     }
+    // Create comments table
+    await client.execute(`
+    CREATE TABLE IF NOT EXISTS comments (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+    await client.execute("CREATE INDEX IF NOT EXISTS idx_comments_task_id ON comments(task_id)");
 }
 // DB 初期化
 export async function initDb() {

package/dist/db/schema.d.ts

@@ -190,3 +190,86 @@ export declare const tasks: import("drizzle-orm/sqlite-core").SQLiteTableWithCol
 export type Task = typeof tasks.$inferSelect;
 export type NewTask = typeof tasks.$inferInsert;
 export type TaskStatus = 'inbox' | 'next' | 'waiting' | 'someday' | 'done';
+export declare const comments: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "comments";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "comments";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        taskId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "task_id";
+            tableName: "comments";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "comments";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "comments";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+export type Comment = typeof comments.$inferSelect;
+export type NewComment = typeof comments.$inferInsert;

package/dist/db/schema.js

@@ -11,3 +11,9 @@ export const tasks = sqliteTable('tasks', {
     createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
     updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
 });
+export const comments = sqliteTable('comments', {
+    id: text('id').primaryKey(),
+    taskId: text('task_id').notNull(),
+    content: text('content').notNull(),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+});