@mindtnv/todoist-cli 0.4.0 → 0.5.0

package/src/cli/label.ts

@@ -0,0 +1,120 @@
+import type { Command } from "commander";
+import chalk from "chalk";
+import { getLabels, createLabel, updateLabel, deleteLabel } from "../api/labels.ts";
+import { handleError } from "../utils/errors.ts";
+import { cliExit } from "../utils/exit.ts";
+import { ID_WIDTH } from "../utils/format.ts";
+import { saveLastList, resolveLabelArg } from "../utils/resolve.ts";
+
+const NAME_WIDTH = 25;
+const COLOR_WIDTH = 12;
+
+export function registerLabelCommand(program: Command): void {
+  const label = program
+    .command("label")
+    .description("Manage labels");
+
+  label
+    .command("list")
+    .description("List all labels")
+    .option("--json <fields>", "Output JSON with specified fields (comma-separated)")
+    .option("-q, --quiet", "Print only label IDs")
+    .action(async (opts: { json?: string; quiet?: boolean }) => {
+      try {
+        const labels = await getLabels();
+
+        if (opts.quiet) {
+          for (const l of labels) console.log(l.id);
+          return;
+        }
+
+        if (opts.json !== undefined) {
+          const fields = opts.json.split(",").map((f) => f.trim());
+          const data = labels.map((l) => {
+            const obj: Record<string, unknown> = {};
+            for (const f of fields) {
+              if (f in l) obj[f] = (l as unknown as Record<string, unknown>)[f];
+            }
+            return obj;
+          });
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        if (labels.length === 0) {
+          console.log(chalk.dim("No labels found."));
+          return;
+        }
+
+        const header = `${"#".padStart(3)} ${"ID".padEnd(ID_WIDTH)} ${"Name".padEnd(NAME_WIDTH)} ${"Color".padEnd(COLOR_WIDTH)} Favorite`;
+        console.log(chalk.bold(header));
+        console.log(chalk.dim("-".repeat(3 + 1 + ID_WIDTH + 1 + NAME_WIDTH + 1 + COLOR_WIDTH + 1 + 8)));
+
+        for (let i = 0; i < labels.length; i++) {
+          const l = labels[i]!;
+          const num = chalk.dim(String(i + 1).padStart(3));
+          const id = l.id.padEnd(ID_WIDTH);
+          const name = l.name.padEnd(NAME_WIDTH);
+          const color = l.color.padEnd(COLOR_WIDTH);
+          const fav = l.is_favorite ? chalk.yellow("*") : " ";
+          console.log(`${num} ${id} ${name} ${color} ${fav}`);
+        }
+
+        saveLastList("label", labels.map(l => ({ id: l.id, label: l.name })));
+      } catch (err) {
+        handleError(err);
+      }
+    });
+
+  label
+    .command("create")
+    .description("Create a new label")
+    .argument("<name>", "Label name")
+    .action(async (name: string) => {
+      try {
+        const result = await createLabel({ name });
+        console.log(chalk.green(`Label created: ${result.name} (${result.id})`));
+      } catch (err) {
+        handleError(err);
+      }
+    });
+
+  label
+    .command("update")
+    .description("Update a label")
+    .argument("<id>", "Label ID")
+    .option("--name <name>", "New label name")
+    .option("--color <color>", "New color")
+    .action(async (rawId: string, opts: { name?: string; color?: string }) => {
+      try {
+        const id = await resolveLabelArg(rawId);
+        const params: Record<string, unknown> = {};
+        if (opts.name) params.name = opts.name;
+        if (opts.color) params.color = opts.color;
+
+        if (Object.keys(params).length === 0) {
+          console.error(chalk.red("No update options provided. Use --name or --color."));
+          cliExit(1);
+        }
+
+        const result = await updateLabel(id, params);
+        console.log(chalk.green(`Label ${result.id} updated: ${result.name}`));
+      } catch (err) {
+        handleError(err);
+      }
+    });
+
+  label
+    .command("delete")
+    .description("Delete a label")
+    .argument("<id>", "Label ID")
+    .action(async (rawId: string) => {
+      try {
+        const id = await resolveLabelArg(rawId);
+        await deleteLabel(id);
+        console.log(chalk.green(`Label ${id} deleted.`));
+      } catch (err) {
+        handleError(err);
+      }
+    });
+}

package/src/cli/log.ts

@@ -0,0 +1,57 @@
+import type { Command } from "commander";
+import chalk from "chalk";
+import { getActivity } from "../api/activity.ts";
+import { padEnd } from "../utils/format.ts";
+import { handleError } from "../utils/errors.ts";
+
+function eventColor(eventType: string): (text: string) => string {
+  switch (eventType) {
+    case "completed": return chalk.green;
+    case "added":
+    case "created": return chalk.blue;
+    case "updated": return chalk.yellow;
+    case "deleted": return chalk.red;
+    default: return chalk.white;
+  }
+}
+
+function formatTimestamp(iso: string): string {
+  const d = new Date(iso);
+  return d.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false }) +
+    " " + d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+
+export function registerLogCommand(program: Command): void {
+  program
+    .command("log")
+    .description("Show activity log")
+    .option("-n, --limit <number>", "Number of events to show", "30")
+    .action(async (opts: { limit: string }) => {
+      try {
+        const events = await getActivity(parseInt(opts.limit, 10));
+
+        if (events.length === 0) {
+          console.log(chalk.dim("No activity found."));
+          return;
+        }
+
+        console.log(chalk.bold("Activity log:"));
+        console.log(chalk.dim("-".repeat(70)));
+
+        for (const e of events) {
+          const time = chalk.dim(formatTimestamp(e.event_date));
+          const colorFn = eventColor(e.event_type);
+          const type = padEnd(colorFn(e.event_type), 12);
+          const extra = e.extra_data && typeof e.extra_data === "object" && "content" in e.extra_data
+            ? chalk.dim(` — ${String(e.extra_data.content)}`)
+            : `${e.object_type}`;
+          console.log(`  ${time}  ${type}  ${extra}`);
+        }
+
+        console.log("");
+        console.log(chalk.dim(`Total: ${events.length} event${events.length === 1 ? "" : "s"}`));
+      } catch (err) {
+        handleError(err);
+      }
+    });
+}

package/src/cli/matrix.ts

@@ -0,0 +1,100 @@
+import type { Command } from "commander";
+import chalk from "chalk";
+import type { Task, Priority } from "../api/types.ts";
+import { getTasks } from "../api/tasks.ts";
+import { padEnd, truncate } from "../utils/format.ts";
+import { handleError } from "../utils/errors.ts";
+
+const COL_WIDTH = 35;
+
+function formatTaskLine(task: Task): string {
+  const content = truncate(task.content, COL_WIDTH - 4);
+  return `  ${content}`;
+}
+
+function renderQuadrant(title: string, tasks: Task[], color: (s: string) => string): string[] {
+  const lines: string[] = [];
+  lines.push(color(` ${title}`));
+  if (tasks.length === 0) {
+    lines.push(chalk.dim("  (empty)"));
+  } else {
+    for (const t of tasks.slice(0, 8)) {
+      lines.push(formatTaskLine(t));
+    }
+    if (tasks.length > 8) {
+      lines.push(chalk.dim(`  +${tasks.length - 8} more`));
+    }
+  }
+  return lines;
+}
+
+function mergeColumns(left: string[], right: string[], colWidth: number): string[] {
+  const maxLen = Math.max(left.length, right.length);
+  const result: string[] = [];
+  for (let i = 0; i < maxLen; i++) {
+    const l = padEnd(left[i] ?? "", colWidth);
+    const r = padEnd(right[i] ?? "", colWidth);
+    result.push(`${l} ${chalk.dim("\u2502")} ${r}`);
+  }
+  return result;
+}
+
+export function registerMatrixCommand(program: Command): void {
+  program
+    .command("matrix")
+    .description("Eisenhower matrix view")
+    .option("--today", "Only show tasks due today")
+    .action(async (opts: { today?: boolean }) => {
+      try {
+        let tasks: Task[];
+        if (opts.today) {
+          tasks = await getTasks({ filter: "today" });
+        } else {
+          tasks = await getTasks();
+        }
+
+        const buckets: Record<Priority, Task[]> = { 1: [], 2: [], 3: [], 4: [] };
+        for (const t of tasks) {
+          buckets[t.priority].push(t);
+        }
+
+        const totalWidth = COL_WIDTH * 2 + 3;
+        const hLine = chalk.dim("\u2500".repeat(COL_WIDTH));
+        const hSep = `${hLine}${chalk.dim("\u253C")}${hLine}`;
+        const topBorder = `${chalk.dim("\u250C")}${hLine}${chalk.dim("\u252C")}${hLine}${chalk.dim("\u2510")}`;
+        const midBorder = `${chalk.dim("\u251C")}${hSep.replace(/\u253C/, "\u253C")}${chalk.dim("\u2524")}`;
+        const botBorder = `${chalk.dim("\u2514")}${hLine}${chalk.dim("\u2534")}${hLine}${chalk.dim("\u2518")}`;
+
+        const header = chalk.dim(" ".repeat(Math.floor((totalWidth - 20) / 2))) + chalk.bold("Eisenhower Matrix");
+        console.log("");
+        console.log(header);
+        console.log("");
+
+        // Top quadrants: p4 (DO FIRST / urgent) | p3 (SCHEDULE)
+        const q1 = renderQuadrant("DO FIRST (p4)", buckets[4], chalk.red.bold);
+        const q2 = renderQuadrant("SCHEDULE (p3)", buckets[3], chalk.yellow.bold);
+        const topRows = mergeColumns(q1, q2, COL_WIDTH);
+
+        // Bottom quadrants: p2 (DELEGATE) | p1 (ELIMINATE / normal)
+        const q3 = renderQuadrant("DELEGATE (p2)", buckets[2], chalk.blue.bold);
+        const q4 = renderQuadrant("ELIMINATE (p1)", buckets[1], chalk.white.bold);
+        const botRows = mergeColumns(q3, q4, COL_WIDTH);
+
+        console.log(topBorder);
+        for (const row of topRows) {
+          console.log(`${chalk.dim("\u2502")}${row}${chalk.dim("\u2502")}`);
+        }
+        console.log(midBorder);
+        for (const row of botRows) {
+          console.log(`${chalk.dim("\u2502")}${row}${chalk.dim("\u2502")}`);
+        }
+        console.log(botBorder);
+        console.log("");
+
+        const total = tasks.length;
+        console.log(chalk.dim(`Total: ${total} task${total === 1 ? "" : "s"} — p4: ${buckets[4].length}, p3: ${buckets[3].length}, p2: ${buckets[2].length}, p1: ${buckets[1].length}`));
+      } catch (err) {
+        handleError(err);
+      }
+    });
+}

package/src/cli/plugin-loader.ts

@@ -0,0 +1,38 @@
+import type { Command } from "commander";
+import { createHookRegistry } from "../plugins/hook-registry.ts";
+import { createViewRegistry } from "../plugins/view-registry.ts";
+import { createExtensionRegistry } from "../plugins/extension-registry.ts";
+import { createPaletteRegistry } from "../plugins/palette-registry.ts";
+import { loadPlugins, type LoadedPlugins } from "../plugins/loader.ts";
+import type { HookRegistry } from "../plugins/types.ts";
+
+let loadedPlugins: LoadedPlugins | null = null;
+let hookRegistry: HookRegistry | null = null;
+
+/**
+ * Load all plugins and register their CLI commands on the Commander program.
+ */
+export async function loadCliPlugins(program: Command): Promise<void> {
+  const hooks = createHookRegistry();
+  const views = createViewRegistry();
+  const extensions = createExtensionRegistry();
+  const palette = createPaletteRegistry();
+
+  const loaded = await loadPlugins(hooks, views, extensions, palette);
+  loadedPlugins = loaded;
+  hookRegistry = hooks;
+
+  for (const { plugin, ctx } of loaded.plugins) {
+    if (plugin.registerCommands) {
+      plugin.registerCommands(program, ctx);
+    }
+  }
+}
+
+export function getCliHookRegistry(): HookRegistry | null {
+  return hookRegistry;
+}
+
+export function getCliLoadedPlugins(): LoadedPlugins | null {
+  return loadedPlugins;
+}

package/src/cli/plugin.ts

@@ -0,0 +1,289 @@
+import type { Command } from "commander";
+import chalk from "chalk";
+import {
+  discoverPlugins,
+  installPlugin,
+  removePlugin,
+  updatePlugin,
+  updateAllPlugins,
+  enablePlugin,
+  disablePlugin,
+  getRegisteredMarketplaces,
+  addMarketplace,
+  removeMarketplace,
+  refreshMarketplaceCache,
+} from "../plugins/marketplace.ts";
+import { getConfig } from "../config/index.ts";
+
+export function registerPluginCommand(program: Command): void {
+  const plugin = program
+    .command("plugin")
+    .description("Manage plugins and marketplaces");
+
+  // ── todoist plugin list ──
+  plugin
+    .command("list")
+    .description("List installed plugins")
+    .action(() => {
+      try {
+        const config = getConfig();
+        const plugins = config.plugins;
+
+        if (!plugins || Object.keys(plugins).length === 0) {
+          console.log(chalk.dim("No plugins installed."));
+          console.log(chalk.dim("Discover plugins with: todoist plugin discover"));
+          return;
+        }
+
+        console.log(chalk.bold("Installed Plugins"));
+        console.log("");
+
+        for (const [name, entry] of Object.entries(plugins)) {
+          const isEnabled = entry.enabled !== false;
+          const status = isEnabled ? chalk.green("●") : chalk.yellow("○");
+          const statusLabel = isEnabled ? chalk.green("enabled") : chalk.yellow("disabled");
+          const version = (entry.version as string) ?? "unknown";
+          const source = (entry.source as string) ?? "";
+
+          console.log(
+            `  ${status} ${chalk.bold(name)} ${chalk.cyan("v" + version)} ${statusLabel} ${chalk.dim(source)}`,
+          );
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin discover ──
+  plugin
+    .command("discover")
+    .description("Browse available plugins from all marketplaces")
+    .action(async () => {
+      try {
+        console.log(chalk.dim("Fetching plugins from marketplaces..."));
+        const discovered = await discoverPlugins();
+
+        if (discovered.length === 0) {
+          console.log(chalk.dim("No plugins found in any marketplace."));
+          return;
+        }
+
+        // Group by marketplace
+        const grouped = new Map<string, typeof discovered>();
+        for (const plugin of discovered) {
+          const group = grouped.get(plugin.marketplace) ?? [];
+          group.push(plugin);
+          grouped.set(plugin.marketplace, group);
+        }
+
+        for (const [marketplace, plugins] of grouped) {
+          console.log("");
+          console.log(chalk.bold.underline(marketplace));
+          console.log("");
+
+          for (const p of plugins) {
+            let indicator: string;
+            if (p.installed && p.enabled) {
+              indicator = chalk.green("●");
+            } else if (p.installed && !p.enabled) {
+              indicator = chalk.yellow("◐");
+            } else {
+              indicator = chalk.dim("○");
+            }
+
+            const version = p.version ? chalk.cyan("v" + p.version) : "";
+            const description = p.description ? chalk.dim(p.description) : "";
+
+            console.log(`  ${indicator} ${chalk.bold(p.name)} ${version} ${description}`);
+          }
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin install <name> ──
+  plugin
+    .command("install")
+    .description("Install a plugin (optionally name@marketplace)")
+    .argument("<name>", "Plugin name (or name@marketplace)")
+    .action(async (nameArg: string) => {
+      try {
+        let pluginName = nameArg;
+        let marketplaceName: string | undefined;
+
+        // Parse name@marketplace syntax
+        const atIndex = nameArg.lastIndexOf("@");
+        if (atIndex > 0) {
+          pluginName = nameArg.substring(0, atIndex);
+          marketplaceName = nameArg.substring(atIndex + 1);
+        }
+
+        console.log(chalk.dim(`Installing plugin "${pluginName}"...`));
+        const result = await installPlugin(pluginName, marketplaceName);
+        console.log(chalk.green(`Installed ${result.name} v${result.version} from ${result.marketplace}`));
+        if (result.description) {
+          console.log(chalk.dim(`  ${result.description}`));
+        }
+      } catch (err) {
+        console.error(chalk.red(`Failed to install: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin remove <name> ──
+  plugin
+    .command("remove")
+    .description("Remove an installed plugin")
+    .argument("<name>", "Plugin name")
+    .action((name: string) => {
+      try {
+        removePlugin(name);
+        console.log(chalk.green(`Removed ${name}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin update [name] ──
+  plugin
+    .command("update")
+    .description("Update a specific plugin or all plugins")
+    .argument("[name]", "Plugin name (omit to update all)")
+    .action(async (name?: string) => {
+      try {
+        if (name) {
+          const result = await updatePlugin(name);
+          if (result.updated) {
+            console.log(chalk.green(`${result.name}: ${result.message}`));
+          } else {
+            console.log(chalk.dim(`${result.name}: ${result.message}`));
+          }
+        } else {
+          console.log(chalk.dim("Updating all plugins..."));
+          const results = await updateAllPlugins();
+
+          if (results.length === 0) {
+            console.log(chalk.dim("No plugins installed."));
+            return;
+          }
+
+          for (const result of results) {
+            if (result.updated) {
+              console.log(chalk.green(`  ${result.name}: ${result.message}`));
+            } else {
+              console.log(chalk.dim(`  ${result.name}: ${result.message}`));
+            }
+          }
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin enable <name> ──
+  plugin
+    .command("enable")
+    .description("Enable a disabled plugin")
+    .argument("<name>", "Plugin name")
+    .action((name: string) => {
+      try {
+        enablePlugin(name);
+        console.log(chalk.green(`Enabled ${name}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin disable <name> ──
+  plugin
+    .command("disable")
+    .description("Disable a plugin without removing it")
+    .argument("<name>", "Plugin name")
+    .action((name: string) => {
+      try {
+        disablePlugin(name);
+        console.log(chalk.yellow(`Disabled ${name}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin marketplace ──
+  const marketplace = plugin
+    .command("marketplace")
+    .description("Manage plugin marketplaces");
+
+  // ── todoist plugin marketplace list ──
+  marketplace
+    .command("list")
+    .description("List registered marketplaces")
+    .action(() => {
+      try {
+        const marketplaces = getRegisteredMarketplaces();
+
+        console.log(chalk.bold("Registered Marketplaces"));
+        console.log("");
+
+        for (const m of marketplaces) {
+          const autoUpdate = m.autoUpdate ? chalk.green("auto-update") : chalk.dim("manual");
+          console.log(`  ${chalk.bold(m.name)} ${chalk.dim(m.source)} ${autoUpdate}`);
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin marketplace add <source> ──
+  marketplace
+    .command("add")
+    .description("Add a marketplace (e.g. github:user/repo)")
+    .argument("<source>", "Marketplace source (github:user/repo)")
+    .action((source: string) => {
+      try {
+        const name = addMarketplace(source);
+        console.log(chalk.green(`Added marketplace "${name}" from ${source}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin marketplace remove <name> ──
+  marketplace
+    .command("remove")
+    .description("Remove a registered marketplace")
+    .argument("<name>", "Marketplace name")
+    .action((name: string) => {
+      try {
+        removeMarketplace(name);
+        console.log(chalk.green(`Removed marketplace "${name}"`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+
+  // ── todoist plugin marketplace refresh [name] ──
+  marketplace
+    .command("refresh")
+    .description("Refresh marketplace cache")
+    .argument("[name]", "Marketplace name (omit to refresh all)")
+    .action(async (name?: string) => {
+      try {
+        console.log(chalk.dim(`Refreshing ${name ? `"${name}"` : "all marketplaces"}...`));
+        await refreshMarketplaceCache(name);
+        console.log(chalk.green(`Marketplace cache refreshed.`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+    });
+}