@qodalis/cli-todo 0.0.6 → 2.0.0-beta.2

package/package.json

@@ -1,44 +1,36 @@
 {
   "name": "@qodalis/cli-todo",
-  "version": "0.0.6",
-  "description": "A command-line tool for managing your tasks efficiently. Add, list, complete, and remove TODO items with simple commands.",
+  "version": "2.0.0-beta.2",
+  "description": "@qodalis/cli extension for managing TODO tasks with add, list, complete, and remove commands.",
   "author": "Nicolae Lupei, Qodalis Solutions",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/qodalis-solutions/angular-web-cli"
+    "url": "https://github.com/qodalis-solutions/web-cli"
   },
   "homepage": "https://qodalis.com",
   "keywords": [
-    "angular",
     "cli",
     "qodalis",
     "terminal",
-    "todo"
+    "todo",
+    "tasks",
+    "task-management"
   ],
-  "umd": "./umd/index.js",
-  "unpkg": "./umd/index.js",
-  "peerDependencies": {
-    "@angular/common": "^16.2.0",
-    "@angular/core": "^16.2.0"
-  },
+  "umd": "./umd/index.global.js",
+  "unpkg": "./umd/index.global.js",
   "dependencies": {
-    "tslib": "^2.3.0",
-    "@qodalis/cli-core": "^0.0.16",
-    "@qodalis/angular-cli": "^1.0.37"
+    "@qodalis/cli-core": "2.0.0-beta.2"
   },
   "sideEffects": false,
-  "module": "fesm2022/qodalis-cli-todo.mjs",
-  "typings": "index.d.ts",
+  "main": "./public-api.js",
+  "module": "./public-api.mjs",
+  "types": "./public-api.d.ts",
   "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
     ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/qodalis-cli-todo.mjs",
-      "esm": "./esm2022/qodalis-cli-todo.mjs",
-      "default": "./fesm2022/qodalis-cli-todo.mjs"
+      "types": "./public-api.d.ts",
+      "import": "./public-api.mjs",
+      "require": "./public-api.js"
     }
   }
-}
+}

package/public-api.d.mts

@@ -0,0 +1,48 @@
+import * as _qodalis_cli_core from '@qodalis/cli-core';
+import { ICliCommandProcessor, CliProcessorMetadata, CliStateConfiguration, CliProcessCommand, ICliExecutionContext, ICliCompletionProvider, ICliCompletionContext, ICliModule } from '@qodalis/cli-core';
+
+type TodoItem = {
+    id: number;
+    text: string;
+    completed: boolean;
+    createdAt: string;
+    completedAt?: string;
+    dueDate?: string;
+};
+declare function parseDueDate(input: string): string | null;
+declare function formatRelativeDate(isoDate: string): string;
+declare function isOverdue(todo: TodoItem): boolean;
+declare function migrateTodoItem(item: any): TodoItem;
+declare function lineThroughText(text: string): string;
+
+declare class CliTodoCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    version: string;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    stateConfiguration?: CliStateConfiguration;
+    private todos;
+    private nextId;
+    getTodos(): TodoItem[];
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    initialize(context: ICliExecutionContext): Promise<void>;
+    private formatTodoLine;
+    private registerSubProcessors;
+    private loadFromOldStorage;
+    private saveToStorage;
+}
+
+declare class CliTodoIdCompletionProvider implements ICliCompletionProvider {
+    private readonly todoProcessor;
+    priority: number;
+    constructor(todoProcessor: CliTodoCommandProcessor);
+    getCompletions(context: ICliCompletionContext): string[];
+}
+
+declare const todoModule: ICliModule;
+
+export { CliTodoCommandProcessor, CliTodoIdCompletionProvider, type TodoItem, formatRelativeDate, isOverdue, lineThroughText, migrateTodoItem, parseDueDate, todoModule };

package/public-api.d.ts

@@ -1,2 +1,48 @@
-export * from './lib/cli-todo.module';
-export * from './lib/processors/cli-todo-command-processor';
+import * as _qodalis_cli_core from '@qodalis/cli-core';
+import { ICliCommandProcessor, CliProcessorMetadata, CliStateConfiguration, CliProcessCommand, ICliExecutionContext, ICliCompletionProvider, ICliCompletionContext, ICliModule } from '@qodalis/cli-core';
+
+type TodoItem = {
+    id: number;
+    text: string;
+    completed: boolean;
+    createdAt: string;
+    completedAt?: string;
+    dueDate?: string;
+};
+declare function parseDueDate(input: string): string | null;
+declare function formatRelativeDate(isoDate: string): string;
+declare function isOverdue(todo: TodoItem): boolean;
+declare function migrateTodoItem(item: any): TodoItem;
+declare function lineThroughText(text: string): string;
+
+declare class CliTodoCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    version: string;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    stateConfiguration?: CliStateConfiguration;
+    private todos;
+    private nextId;
+    getTodos(): TodoItem[];
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    initialize(context: ICliExecutionContext): Promise<void>;
+    private formatTodoLine;
+    private registerSubProcessors;
+    private loadFromOldStorage;
+    private saveToStorage;
+}
+
+declare class CliTodoIdCompletionProvider implements ICliCompletionProvider {
+    private readonly todoProcessor;
+    priority: number;
+    constructor(todoProcessor: CliTodoCommandProcessor);
+    getCompletions(context: ICliCompletionContext): string[];
+}
+
+declare const todoModule: ICliModule;
+
+export { CliTodoCommandProcessor, CliTodoIdCompletionProvider, type TodoItem, formatRelativeDate, isOverdue, lineThroughText, migrateTodoItem, parseDueDate, todoModule };

package/public-api.js

@@ -0,0 +1,521 @@
+'use strict';
+
+var cliCore = require('@qodalis/cli-core');
+
+// src/lib/utilities/index.ts
+var DAY_NAMES = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+var MONTH_NAMES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function startOfDay(date) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function parseDueDate(input) {
+  const trimmed = input.trim().toLowerCase();
+  const now = /* @__PURE__ */ new Date();
+  const today = startOfDay(now);
+  if (trimmed === "today") {
+    return today.toISOString();
+  }
+  if (trimmed === "tomorrow") {
+    const d = new Date(today);
+    d.setDate(d.getDate() + 1);
+    return d.toISOString();
+  }
+  if (trimmed === "yesterday") {
+    const d = new Date(today);
+    d.setDate(d.getDate() - 1);
+    return d.toISOString();
+  }
+  if (trimmed === "next week") {
+    const d = new Date(today);
+    d.setDate(d.getDate() + 7);
+    return d.toISOString();
+  }
+  if (trimmed === "next month") {
+    const d = new Date(today);
+    d.setMonth(d.getMonth() + 1);
+    return d.toISOString();
+  }
+  const dayIndex = DAY_NAMES.indexOf(trimmed);
+  if (dayIndex !== -1) {
+    const d = new Date(today);
+    const currentDay = d.getDay();
+    let daysUntil = dayIndex - currentDay;
+    if (daysUntil <= 0) daysUntil += 7;
+    d.setDate(d.getDate() + daysUntil);
+    return d.toISOString();
+  }
+  const isoMatch = trimmed.match(/^\d{4}-\d{2}-\d{2}$/);
+  if (isoMatch) {
+    const d = /* @__PURE__ */ new Date(trimmed + "T00:00:00");
+    if (!isNaN(d.getTime())) {
+      return startOfDay(d).toISOString();
+    }
+  }
+  return null;
+}
+function formatRelativeDate(isoDate) {
+  const target = startOfDay(new Date(isoDate));
+  const today = startOfDay(/* @__PURE__ */ new Date());
+  const diffMs = target.getTime() - today.getTime();
+  const diffDays = Math.round(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays === 0) return "due: today";
+  if (diffDays === 1) return "due: tomorrow";
+  if (diffDays === -1) return "overdue: yesterday";
+  if (diffDays > 1 && diffDays <= 14) return `due: in ${diffDays} days`;
+  if (diffDays < -1) return `overdue: ${Math.abs(diffDays)} days ago`;
+  const d = new Date(isoDate);
+  return `due: ${MONTH_NAMES[d.getMonth()]} ${d.getDate()}`;
+}
+function isOverdue(todo) {
+  if (todo.completed || !todo.dueDate) return false;
+  const target = startOfDay(new Date(todo.dueDate));
+  const today = startOfDay(/* @__PURE__ */ new Date());
+  return target.getTime() < today.getTime();
+}
+function migrateTodoItem(item) {
+  return {
+    id: item.id,
+    text: item.text,
+    completed: item.completed ?? false,
+    createdAt: item.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: item.completedAt,
+    dueDate: item.dueDate
+  };
+}
+function lineThroughText(text) {
+  return text.split("").map((char) => char + "\u0336").join("");
+}
+
+// src/lib/version.ts
+var LIBRARY_VERSION = "2.0.0-beta.2";
+var API_VERSION = 2;
+
+// src/lib/processors/cli-todo-command-processor.ts
+var CliTodoCommandProcessor = class {
+  constructor() {
+    this.command = "todo";
+    this.description = "Manage your tasks from the terminal. Add, list, edit, complete, and remove TODO items.";
+    this.author = cliCore.DefaultLibraryAuthor;
+    this.version = LIBRARY_VERSION;
+    this.processors = [];
+    this.metadata = {
+      icon: "\u{1F4DD}",
+      requiredCoreVersion: ">=2.0.0 <3.0.0",
+      requiredCliVersion: ">=2.0.0 <3.0.0"
+    };
+    this.stateConfiguration = {
+      initialState: {
+        todos: this.loadFromOldStorage() ?? []
+      }
+    };
+    this.todos = [];
+    this.nextId = 1;
+    this.registerSubProcessors();
+  }
+  getTodos() {
+    return this.todos;
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer } = context;
+    writer.writeln(this.description);
+    writer.writeln();
+    writer.writeln(writer.wrapInColor("Commands:", cliCore.CliForegroundColor.Yellow));
+    writer.writeln(`  ${writer.wrapInColor("todo ls", cliCore.CliForegroundColor.Cyan)}                    List all tasks`);
+    writer.writeln(`  ${writer.wrapInColor("todo ls --pending", cliCore.CliForegroundColor.Cyan)}          List pending tasks only`);
+    writer.writeln(`  ${writer.wrapInColor("todo ls --completed", cliCore.CliForegroundColor.Cyan)}        List completed tasks only`);
+    writer.writeln(`  ${writer.wrapInColor("todo ls --overdue", cliCore.CliForegroundColor.Cyan)}          List overdue tasks only`);
+    writer.writeln(`  ${writer.wrapInColor("todo add <text>", cliCore.CliForegroundColor.Cyan)}            Add a new task`);
+    writer.writeln(`  ${writer.wrapInColor("todo add <text> --due <date>", cliCore.CliForegroundColor.Cyan)}  Add with due date`);
+    writer.writeln(`  ${writer.wrapInColor("todo edit <id> <new text>", cliCore.CliForegroundColor.Cyan)}  Edit a task`);
+    writer.writeln(`  ${writer.wrapInColor("todo done <id>", cliCore.CliForegroundColor.Cyan)}             Mark a task as done`);
+    writer.writeln(`  ${writer.wrapInColor("todo toggle <id>", cliCore.CliForegroundColor.Cyan)}           Toggle done/undone`);
+    writer.writeln(`  ${writer.wrapInColor("todo rm <id>", cliCore.CliForegroundColor.Cyan)}               Remove a task`);
+    writer.writeln(`  ${writer.wrapInColor("todo rm --all", cliCore.CliForegroundColor.Cyan)}              Remove all tasks`);
+    writer.writeln();
+    writer.writeln(writer.wrapInColor("Due date formats:", cliCore.CliForegroundColor.Yellow));
+    writer.writeln(`  today, tomorrow, monday..sunday, next week, next month, YYYY-MM-DD`);
+    writer.writeln();
+    writer.writeln(writer.wrapInColor("Examples:", cliCore.CliForegroundColor.Yellow));
+    writer.writeln(`  todo add Buy groceries --due tomorrow`);
+    writer.writeln(`  todo ls --pending`);
+    writer.writeln(`  todo edit 3 Buy organic groceries`);
+    writer.writeln(`  todo done 1`);
+    writer.writeln(`  todo toggle 2`);
+  }
+  async initialize(context) {
+    context.state.select((x) => x["todos"]).subscribe((todos) => {
+      this.todos = (todos || []).map(migrateTodoItem);
+      this.nextId = this.todos.length > 0 ? Math.max(...this.todos.map((t) => t.id)) + 1 : 1;
+    });
+  }
+  formatTodoLine(todo, writer) {
+    const check = todo.completed ? writer.wrapInColor(cliCore.CliIcon.CheckIcon, cliCore.CliForegroundColor.Green) : " ";
+    const text = todo.completed ? lineThroughText(todo.text) : todo.text;
+    let suffix = "";
+    if (todo.completed) {
+      suffix = writer.wrapInColor("  done", cliCore.CliForegroundColor.Green);
+    } else if (todo.dueDate) {
+      const rel = formatRelativeDate(todo.dueDate);
+      const color = isOverdue(todo) ? cliCore.CliForegroundColor.Red : cliCore.CliForegroundColor.Yellow;
+      suffix = "  " + writer.wrapInColor(rel, color);
+    }
+    return `  [${check}] #${todo.id} - ${text}${suffix}`;
+  }
+  registerSubProcessors() {
+    this.processors = [
+      // ── ls ──────────────────────────────────────────────
+      {
+        command: "ls",
+        aliases: ["list"],
+        description: "List TODO items",
+        parameters: [
+          {
+            name: "pending",
+            description: "Show only pending tasks",
+            type: "boolean",
+            required: false
+          },
+          {
+            name: "completed",
+            description: "Show only completed tasks",
+            type: "boolean",
+            required: false
+          },
+          {
+            name: "overdue",
+            description: "Show only overdue tasks",
+            type: "boolean",
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          if (this.todos.length === 0) {
+            context.writer.writeWarning("No tasks yet.");
+            context.writer.writeln('Use "todo add <text>" to create one.');
+            context.process.output([]);
+            return;
+          }
+          let filtered = [...this.todos];
+          const args = command.args;
+          if (args["pending"]) {
+            filtered = filtered.filter((t) => !t.completed);
+          } else if (args["completed"]) {
+            filtered = filtered.filter((t) => t.completed);
+          } else if (args["overdue"]) {
+            filtered = filtered.filter((t) => isOverdue(t));
+          }
+          const doneCount = this.todos.filter((t) => t.completed).length;
+          context.writer.writeln(
+            context.writer.wrapInColor(
+              `Todos (${doneCount}/${this.todos.length} done)`,
+              cliCore.CliForegroundColor.Cyan
+            )
+          );
+          if (filtered.length === 0) {
+            context.writer.writeln("  No matching tasks.");
+          } else {
+            filtered.forEach((todo) => {
+              context.writer.writeln(
+                this.formatTodoLine(todo, context.writer)
+              );
+            });
+          }
+          context.process.output(filtered);
+        }
+      },
+      // ── add ─────────────────────────────────────────────
+      {
+        command: "add",
+        description: "Add a new task",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "due",
+            description: "Due date (today, tomorrow, monday..sunday, next week, next month, YYYY-MM-DD)",
+            type: "string",
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          const text = command.value;
+          if (!text) {
+            context.writer.writeError("Please provide a task description.");
+            return;
+          }
+          let dueDate;
+          const dueArg = command.args["due"];
+          if (dueArg) {
+            const parsed = parseDueDate(dueArg);
+            if (!parsed) {
+              context.writer.writeError(
+                `Invalid due date: "${dueArg}". Use: today, tomorrow, monday..sunday, next week, next month, or YYYY-MM-DD.`
+              );
+              return;
+            }
+            dueDate = parsed;
+          }
+          const newItem = {
+            id: this.nextId++,
+            text,
+            completed: false,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            dueDate
+          };
+          this.todos.push(newItem);
+          await this.saveToStorage(context);
+          let msg = `Added: "${text}"`;
+          if (dueDate) {
+            msg += ` (${formatRelativeDate(dueDate)})`;
+          }
+          context.writer.writeSuccess(msg);
+          context.process.output(newItem);
+        }
+      },
+      // ── edit ────────────────────────────────────────────
+      {
+        command: "edit",
+        description: "Edit a task's text or due date",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "due",
+            description: 'New due date (or "none" to remove)',
+            type: "string",
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          const raw = command.value || "";
+          const spaceIndex = raw.indexOf(" ");
+          const idStr = spaceIndex === -1 ? raw : raw.substring(0, spaceIndex);
+          const newText = spaceIndex === -1 ? void 0 : raw.substring(spaceIndex + 1).trim();
+          const id = parseInt(idStr, 10);
+          if (isNaN(id)) {
+            context.writer.writeError("Usage: todo edit <id> <new text> [--due <date>]");
+            return;
+          }
+          const todo = this.todos.find((t) => t.id === id);
+          if (!todo) {
+            context.writer.writeError(`Task #${id} not found.`);
+            return;
+          }
+          const dueArg = command.args["due"];
+          let changed = false;
+          if (newText) {
+            todo.text = newText;
+            changed = true;
+          }
+          if (dueArg) {
+            if (dueArg === "none") {
+              todo.dueDate = void 0;
+              changed = true;
+            } else {
+              const parsed = parseDueDate(dueArg);
+              if (!parsed) {
+                context.writer.writeError(`Invalid due date: "${dueArg}".`);
+                return;
+              }
+              todo.dueDate = parsed;
+              changed = true;
+            }
+          }
+          if (!changed) {
+            context.writer.writeError("Nothing to update. Provide new text or --due.");
+            return;
+          }
+          await this.saveToStorage(context);
+          context.writer.writeSuccess(`Updated task #${id}.`);
+          context.process.output(todo);
+        }
+      },
+      // ── done ────────────────────────────────────────────
+      {
+        command: "done",
+        aliases: ["complete"],
+        description: "Mark a task as done",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const id = parseInt(command.value || "", 10);
+          if (isNaN(id)) {
+            context.writer.writeError("Please provide a valid task ID.");
+            return;
+          }
+          const todo = this.todos.find((t) => t.id === id);
+          if (!todo) {
+            context.writer.writeError(`Task #${id} not found.`);
+            return;
+          }
+          if (todo.completed) {
+            context.writer.writeInfo(`Task #${id} is already done.`);
+            return;
+          }
+          todo.completed = true;
+          todo.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          await this.saveToStorage(context);
+          context.writer.writeSuccess(`Done: "${todo.text}"`);
+          context.process.output(todo);
+        }
+      },
+      // ── toggle ──────────────────────────────────────────
+      {
+        command: "toggle",
+        description: "Toggle a task between done and undone",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const id = parseInt(command.value || "", 10);
+          if (isNaN(id)) {
+            context.writer.writeError("Please provide a valid task ID.");
+            return;
+          }
+          const todo = this.todos.find((t) => t.id === id);
+          if (!todo) {
+            context.writer.writeError(`Task #${id} not found.`);
+            return;
+          }
+          todo.completed = !todo.completed;
+          todo.completedAt = todo.completed ? (/* @__PURE__ */ new Date()).toISOString() : void 0;
+          await this.saveToStorage(context);
+          const status = todo.completed ? "done" : "reopened";
+          context.writer.writeSuccess(`Task #${id} marked as ${status}.`);
+          context.process.output(todo);
+        }
+      },
+      // ── rm ──────────────────────────────────────────────
+      {
+        command: "rm",
+        aliases: ["remove"],
+        description: "Remove a task by ID",
+        acceptsRawInput: true,
+        parameters: [
+          {
+            name: "all",
+            description: "Remove all tasks",
+            type: "boolean",
+            defaultValue: false,
+            aliases: ["a"],
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          if (command.args["all"] || command.args["a"]) {
+            if (this.todos.length === 0) {
+              context.writer.writeInfo("No tasks to remove.");
+              return;
+            }
+            const confirmed = await context.reader.readConfirm(
+              `Remove all ${this.todos.length} tasks?`,
+              false
+            );
+            if (!confirmed) {
+              context.writer.writeInfo("Cancelled.");
+              return;
+            }
+            this.todos = [];
+            await this.saveToStorage(context);
+            context.writer.writeSuccess("Removed all tasks.");
+            return;
+          }
+          const id = parseInt(command.value, 10);
+          if (isNaN(id)) {
+            context.writer.writeError("Please provide a valid task ID.");
+            return;
+          }
+          const index = this.todos.findIndex((t) => t.id === id);
+          if (index === -1) {
+            context.writer.writeError(`Task #${id} not found.`);
+            return;
+          }
+          const removed = this.todos.splice(index, 1)[0];
+          await this.saveToStorage(context);
+          context.writer.writeSuccess(`Removed: "${removed.text}"`);
+        }
+      }
+    ];
+  }
+  loadFromOldStorage() {
+    const data = localStorage.getItem("todo-items");
+    if (!data) return [];
+    try {
+      return JSON.parse(data).map(migrateTodoItem);
+    } catch {
+      return [];
+    }
+  }
+  async saveToStorage(context) {
+    context.state.updateState({ todos: this.todos });
+    await context.state.persist();
+    localStorage.removeItem("todo-items");
+  }
+};
+
+// src/lib/completion/cli-todo-id-completion-provider.ts
+var TODO_ID_SUBCOMMANDS = /* @__PURE__ */ new Set(["rm", "done", "complete", "toggle", "edit"]);
+var CliTodoIdCompletionProvider = class {
+  constructor(todoProcessor2) {
+    this.todoProcessor = todoProcessor2;
+    this.priority = 50;
+  }
+  getCompletions(context) {
+    const { tokens, tokenIndex, token } = context;
+    if (tokenIndex !== 2 || tokens.length < 2) {
+      return [];
+    }
+    const rootCommand = tokens[0].toLowerCase();
+    if (rootCommand !== "todo") {
+      return [];
+    }
+    const subCommand = tokens[1].toLowerCase();
+    if (!TODO_ID_SUBCOMMANDS.has(subCommand)) {
+      return [];
+    }
+    const todos = this.todoProcessor.getTodos();
+    const lowerPrefix = token.toLowerCase();
+    const filtered = subCommand === "done" || subCommand === "complete" ? todos.filter((t) => !t.completed) : todos;
+    return filtered.map((t) => String(t.id)).filter((id) => id.startsWith(lowerPrefix)).sort((a, b) => Number(a) - Number(b));
+  }
+};
+var todoProcessor = new CliTodoCommandProcessor();
+var todoModule = {
+  apiVersion: API_VERSION,
+  name: "@qodalis/cli-todo",
+  processors: [todoProcessor],
+  services: [
+    {
+      provide: cliCore.ICliCompletionProvider_TOKEN,
+      useValue: new CliTodoIdCompletionProvider(todoProcessor),
+      multi: true
+    }
+  ],
+  translations: {
+    es: { "cli.todo.description": "Gestionar tus tareas desde la terminal" },
+    fr: { "cli.todo.description": "G\xE9rer vos t\xE2ches depuis le terminal" },
+    de: { "cli.todo.description": "Aufgaben \xFCber das Terminal verwalten" },
+    pt: { "cli.todo.description": "Gerenciar suas tarefas pelo terminal" },
+    it: { "cli.todo.description": "Gestire le attivit\xE0 dal terminale" },
+    ja: { "cli.todo.description": "\u30BF\u30FC\u30DF\u30CA\u30EB\u304B\u3089\u30BF\u30B9\u30AF\u3092\u7BA1\u7406" },
+    ko: { "cli.todo.description": "\uD130\uBBF8\uB110\uC5D0\uC11C \uD560 \uC77C \uAD00\uB9AC" },
+    zh: { "cli.todo.description": "\u4ECE\u7EC8\u7AEF\u7BA1\u7406\u4F60\u7684\u4EFB\u52A1" },
+    ru: { "cli.todo.description": "\u0423\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u0437\u0430\u0434\u0430\u0447\u0430\u043C\u0438 \u0438\u0437 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u0430" },
+    ro: { "cli.todo.description": "Gestioneaz\u0103 sarcinile tale din terminal" }
+  }
+};
+
+exports.CliTodoCommandProcessor = CliTodoCommandProcessor;
+exports.CliTodoIdCompletionProvider = CliTodoIdCompletionProvider;
+exports.formatRelativeDate = formatRelativeDate;
+exports.isOverdue = isOverdue;
+exports.lineThroughText = lineThroughText;
+exports.migrateTodoItem = migrateTodoItem;
+exports.parseDueDate = parseDueDate;
+exports.todoModule = todoModule;
+//# sourceMappingURL=public-api.js.map
+//# sourceMappingURL=public-api.js.map