floq 0.0.1

package/dist/commands/move.js

@@ -0,0 +1,50 @@
+import { eq, like } from 'drizzle-orm';
+import { getDb, schema } from '../db/index.js';
+import { t, fmt } from '../i18n/index.js';
+export async function moveTask(taskId, targetStatus, waitingFor) {
+    const db = getDb();
+    const i18n = t();
+    const validStatuses = ['inbox', 'next', 'waiting', 'someday'];
+    if (!validStatuses.includes(targetStatus)) {
+        console.error(fmt(i18n.commands.move.invalidStatus, { status: targetStatus }));
+        console.error(fmt(i18n.commands.move.validStatuses, { statuses: validStatuses.join(', ') }));
+        process.exit(1);
+    }
+    if (targetStatus === 'waiting' && !waitingFor) {
+        console.error(i18n.commands.move.specifyWaiting);
+        process.exit(1);
+    }
+    // Find task by ID prefix
+    const tasks = db
+        .select()
+        .from(schema.tasks)
+        .where(like(schema.tasks.id, `${taskId}%`))
+        .all();
+    if (tasks.length === 0) {
+        console.error(fmt(i18n.commands.move.notFound, { id: taskId }));
+        process.exit(1);
+    }
+    if (tasks.length > 1) {
+        console.error(fmt(i18n.commands.move.multipleMatch, { id: taskId }));
+        for (const task of tasks) {
+            console.error(`  [${task.id.slice(0, 8)}] ${task.title}`);
+        }
+        process.exit(1);
+    }
+    const task = tasks[0];
+    db.update(schema.tasks)
+        .set({
+        status: targetStatus,
+        waitingFor: targetStatus === 'waiting' ? waitingFor : null,
+        updatedAt: new Date(),
+    })
+        .where(eq(schema.tasks.id, task.id))
+        .run();
+    console.log(fmt(i18n.commands.move.success, {
+        title: task.title,
+        status: i18n.status[targetStatus]
+    }));
+    if (waitingFor) {
+        console.log(fmt(i18n.commands.move.waitingFor, { person: waitingFor }));
+    }
+}

package/dist/commands/project.d.ts

@@ -0,0 +1,8 @@
+interface AddProjectOptions {
+    description?: string;
+}
+export declare function addProject(name: string, options: AddProjectOptions): Promise<void>;
+export declare function listProjectsCommand(): Promise<void>;
+export declare function showProject(projectId: string): Promise<void>;
+export declare function completeProject(projectId: string): Promise<void>;
+export {};

package/dist/commands/project.js

@@ -0,0 +1,160 @@
+import { v4 as uuidv4 } from 'uuid';
+import { eq, like, and } from 'drizzle-orm';
+import { getDb, schema } from '../db/index.js';
+import { t, fmt } from '../i18n/index.js';
+export async function addProject(name, options) {
+    const db = getDb();
+    const now = new Date();
+    const i18n = t();
+    // Check if project already exists
+    const existing = db
+        .select()
+        .from(schema.tasks)
+        .where(and(eq(schema.tasks.title, name), eq(schema.tasks.isProject, true)))
+        .get();
+    if (existing) {
+        console.error(fmt(i18n.commands.project.alreadyExists, { name }));
+        process.exit(1);
+    }
+    const project = {
+        id: uuidv4(),
+        title: name,
+        description: options.description,
+        status: 'next',
+        isProject: true,
+        createdAt: now,
+        updatedAt: now,
+    };
+    db.insert(schema.tasks).values(project).run();
+    console.log(fmt(i18n.commands.project.created, { name }));
+}
+export async function listProjectsCommand() {
+    const db = getDb();
+    const i18n = t();
+    const statuses = ['next', 'someday', 'done'];
+    const statusLabels = {
+        next: i18n.projectStatus.active,
+        someday: i18n.projectStatus.someday,
+        done: i18n.projectStatus.completed,
+    };
+    for (const status of statuses) {
+        const projects = db
+            .select()
+            .from(schema.tasks)
+            .where(and(eq(schema.tasks.isProject, true), eq(schema.tasks.status, status)))
+            .all();
+        if (projects.length === 0 && status !== 'next')
+            continue;
+        console.log(`\n${statusLabels[status]} (${projects.length})`);
+        console.log('─'.repeat(40));
+        if (projects.length === 0) {
+            console.log(`  ${i18n.commands.project.noProjects}`);
+        }
+        else {
+            for (const project of projects) {
+                const childTasks = db
+                    .select()
+                    .from(schema.tasks)
+                    .where(eq(schema.tasks.parentId, project.id))
+                    .all();
+                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);
+                console.log(`  [${shortId}] ${project.title} (${fmt(i18n.commands.list.activeDone, { active: activeTasks, done: doneTasks })})`);
+                if (project.description) {
+                    console.log(`            ${project.description}`);
+                }
+            }
+        }
+    }
+    console.log();
+}
+export async function showProject(projectId) {
+    const db = getDb();
+    const i18n = t();
+    // Find project by ID prefix or name
+    let projects = db
+        .select()
+        .from(schema.tasks)
+        .where(and(eq(schema.tasks.isProject, true), like(schema.tasks.id, `${projectId}%`)))
+        .all();
+    if (projects.length === 0) {
+        projects = db
+            .select()
+            .from(schema.tasks)
+            .where(and(eq(schema.tasks.isProject, true), eq(schema.tasks.title, projectId)))
+            .all();
+    }
+    if (projects.length === 0) {
+        console.error(fmt(i18n.commands.project.notFound, { id: projectId }));
+        process.exit(1);
+    }
+    if (projects.length > 1) {
+        console.error(fmt(i18n.commands.project.multipleMatch, { id: projectId }));
+        for (const project of projects) {
+            console.error(`  [${project.id.slice(0, 8)}] ${project.title}`);
+        }
+        process.exit(1);
+    }
+    const project = projects[0];
+    const childTasks = db
+        .select()
+        .from(schema.tasks)
+        .where(eq(schema.tasks.parentId, project.id))
+        .all();
+    console.log(`\nProject: ${project.title}`);
+    console.log('─'.repeat(40));
+    if (project.description) {
+        console.log(fmt(i18n.commands.project.description, { description: project.description }));
+    }
+    console.log(fmt(i18n.commands.project.statusLabel, { status: project.status }));
+    console.log(fmt(i18n.commands.project.tasksCount, { count: childTasks.length }));
+    console.log();
+    const groupedTasks = {
+        inbox: childTasks.filter(t => t.status === 'inbox'),
+        next: childTasks.filter(t => t.status === 'next'),
+        waiting: childTasks.filter(t => t.status === 'waiting'),
+        someday: childTasks.filter(t => t.status === 'someday'),
+        done: childTasks.filter(t => t.status === 'done'),
+    };
+    for (const [status, statusTasks] of Object.entries(groupedTasks)) {
+        if (statusTasks.length === 0)
+            continue;
+        console.log(`  ${i18n.status[status]}:`);
+        for (const task of statusTasks) {
+            const shortId = task.id.slice(0, 8);
+            let line = `    [${shortId}] ${task.title}`;
+            if (task.waitingFor) {
+                line += ` (${i18n.status.waiting.toLowerCase()}: ${task.waitingFor})`;
+            }
+            console.log(line);
+        }
+    }
+    console.log();
+}
+export async function completeProject(projectId) {
+    const db = getDb();
+    const i18n = t();
+    const projects = db
+        .select()
+        .from(schema.tasks)
+        .where(and(eq(schema.tasks.isProject, true), like(schema.tasks.id, `${projectId}%`)))
+        .all();
+    if (projects.length === 0) {
+        console.error(fmt(i18n.commands.project.notFound, { id: projectId }));
+        process.exit(1);
+    }
+    if (projects.length > 1) {
+        console.error(fmt(i18n.commands.project.multipleMatch, { id: projectId }));
+        process.exit(1);
+    }
+    const project = projects[0];
+    db.update(schema.tasks)
+        .set({
+        status: 'done',
+        updatedAt: new Date(),
+    })
+        .where(eq(schema.tasks.id, project.id))
+        .run();
+    console.log(fmt(i18n.commands.project.completed, { name: project.title }));
+}

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+export type Locale = 'en' | 'ja';
+export type ThemeName = 'modern' | 'norton-commander' | 'dos-prompt' | 'turbo-pascal';
+export interface Config {
+    locale: Locale;
+    db_path?: string;
+    theme: ThemeName;
+}
+export declare function loadConfig(): Config;
+export declare function saveConfig(updates: Partial<Config>): void;
+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;

package/dist/config.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname, join, isAbsolute } from 'path';
+import { CONFIG_FILE, DATA_DIR } from './paths.js';
+const DEFAULT_CONFIG = {
+    locale: 'en',
+    theme: 'modern',
+};
+let configCache = null;
+export function loadConfig() {
+    if (configCache) {
+        return configCache;
+    }
+    try {
+        if (existsSync(CONFIG_FILE)) {
+            const content = readFileSync(CONFIG_FILE, 'utf-8');
+            const parsed = JSON.parse(content);
+            configCache = { ...DEFAULT_CONFIG, ...parsed };
+            return configCache;
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    configCache = DEFAULT_CONFIG;
+    return configCache;
+}
+export function saveConfig(updates) {
+    const current = loadConfig();
+    const newConfig = { ...current, ...updates };
+    try {
+        const configDir = dirname(CONFIG_FILE);
+        if (!existsSync(configDir)) {
+            mkdirSync(configDir, { recursive: true });
+        }
+        writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+        configCache = newConfig;
+    }
+    catch {
+        // Ignore errors
+    }
+}
+export function getDbPath() {
+    const config = loadConfig();
+    if (config.db_path) {
+        // 絶対パスならそのまま、相対パスならDATA_DIRからの相対
+        if (isAbsolute(config.db_path)) {
+            return config.db_path;
+        }
+        return join(DATA_DIR, config.db_path);
+    }
+    return join(DATA_DIR, 'gtd.db');
+}
+export function getLocale() {
+    return loadConfig().locale;
+}
+export function setLocale(locale) {
+    saveConfig({ locale });
+}
+export function getThemeName() {
+    return loadConfig().theme || 'modern';
+}
+export function setThemeName(theme) {
+    saveConfig({ theme });
+}

package/dist/db/index.d.ts

@@ -0,0 +1,6 @@
+import Database from 'better-sqlite3';
+import * as schema from './schema.js';
+export declare function getDb(): import("drizzle-orm/better-sqlite3").BetterSQLite3Database<typeof schema> & {
+    $client: Database.Database;
+};
+export { schema };

package/dist/db/index.js

@@ -0,0 +1,72 @@
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+import * as schema from './schema.js';
+import { getDbPath } from '../config.js';
+function ensureDbDir(dbPath) {
+    const dbDir = dirname(dbPath);
+    if (!existsSync(dbDir)) {
+        mkdirSync(dbDir, { recursive: true });
+    }
+}
+function initializeSchema(sqlite) {
+    // Check if we need to migrate from old schema
+    const tableInfo = sqlite.prepare("PRAGMA table_info(tasks)").all();
+    const hasProjectId = tableInfo.some(col => col.name === 'project_id');
+    const hasIsProject = tableInfo.some(col => col.name === 'is_project');
+    const tableExists = tableInfo.length > 0;
+    if (tableExists && hasProjectId && !hasIsProject) {
+        // Migration: old schema -> new schema
+        // Add new columns
+        sqlite.prepare("ALTER TABLE tasks ADD COLUMN is_project INTEGER NOT NULL DEFAULT 0").run();
+        sqlite.prepare("ALTER TABLE tasks ADD COLUMN parent_id TEXT").run();
+        // Migrate: convert projects to tasks with is_project=1
+        const projects = sqlite.prepare("SELECT * FROM projects").all();
+        const insertStmt = sqlite.prepare(`
+      INSERT INTO tasks (id, title, description, status, is_project, parent_id, waiting_for, due_date, created_at, updated_at)
+      VALUES (?, ?, ?, ?, 1, NULL, NULL, NULL, ?, ?)
+    `);
+        for (const p of projects) {
+            const newStatus = p.status === 'active' ? 'next' : (p.status === 'completed' ? 'done' : p.status);
+            insertStmt.run(p.id, p.name, p.description, newStatus, p.created_at, p.updated_at);
+        }
+        // Update parent_id from old project_id
+        sqlite.prepare("UPDATE tasks SET parent_id = project_id WHERE project_id IS NOT NULL").run();
+        // Create new indexes
+        sqlite.prepare("CREATE INDEX IF NOT EXISTS idx_tasks_parent_id ON tasks(parent_id)").run();
+        sqlite.prepare("CREATE INDEX IF NOT EXISTS idx_tasks_is_project ON tasks(is_project)").run();
+    }
+    else if (!tableExists) {
+        // Fresh install: create new schema
+        sqlite.prepare(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'inbox' CHECK(status IN ('inbox', 'next', 'waiting', 'someday', 'done')),
+        is_project INTEGER NOT NULL DEFAULT 0,
+        parent_id TEXT,
+        waiting_for TEXT,
+        due_date INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `).run();
+        sqlite.prepare("CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)").run();
+        sqlite.prepare("CREATE INDEX IF NOT EXISTS idx_tasks_parent_id ON tasks(parent_id)").run();
+        sqlite.prepare("CREATE INDEX IF NOT EXISTS idx_tasks_is_project ON tasks(is_project)").run();
+    }
+}
+let dbInstance = null;
+export function getDb() {
+    if (!dbInstance) {
+        const dbPath = getDbPath();
+        ensureDbDir(dbPath);
+        const sqlite = new Database(dbPath);
+        initializeSchema(sqlite);
+        dbInstance = drizzle(sqlite, { schema });
+    }
+    return dbInstance;
+}
+export { schema };

package/dist/db/schema.d.ts

@@ -0,0 +1,192 @@
+export declare const tasks: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "tasks";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "tasks";
+            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;
+        }>;
+        title: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "title";
+            tableName: "tasks";
+            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;
+        }>;
+        description: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "description";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "inbox" | "next" | "waiting" | "someday" | "done";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["inbox", "next", "waiting", "someday", "done"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        isProject: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "is_project";
+            tableName: "tasks";
+            dataType: "boolean";
+            columnType: "SQLiteBoolean";
+            data: boolean;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        parentId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "parent_id";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        waitingFor: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "waiting_for";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        dueDate: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "due_date";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "tasks";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "tasks";
+            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 Task = typeof tasks.$inferSelect;
+export type NewTask = typeof tasks.$inferInsert;
+export type TaskStatus = 'inbox' | 'next' | 'waiting' | 'someday' | 'done';

package/dist/db/schema.js

@@ -0,0 +1,13 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+export const tasks = sqliteTable('tasks', {
+    id: text('id').primaryKey(),
+    title: text('title').notNull(),
+    description: text('description'),
+    status: text('status', { enum: ['inbox', 'next', 'waiting', 'someday', 'done'] }).notNull().default('inbox'),
+    isProject: integer('is_project', { mode: 'boolean' }).notNull().default(false),
+    parentId: text('parent_id'),
+    waitingFor: text('waiting_for'),
+    dueDate: integer('due_date', { mode: 'timestamp' }),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+});