maro-plugin-tasks 1.0.0

package/.eslintrc.json

@@ -0,0 +1,118 @@
+{
+  "env": {
+    "node": true,
+    "es2021": true
+  },
+  "ignorePatterns": [
+    "dist"
+  ],
+  "extends": [
+    "eslint:recommended",
+    "plugin:de-morgan/recommended-legacy",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:math/recommended-legacy",
+    "plugin:promise/recommended"
+  ],
+  "plugins": [
+    "promise",
+    "@stylistic",
+    "de-morgan",
+    "import",
+    "unused-imports"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 12,
+    "sourceType": "module"
+  },
+  "rules": {
+    "no-inner-declarations": "off",
+    "import/no-deprecated": "error",
+    "import/no-cycle": "error",
+    "import/no-duplicates": "error",
+    "import/enforce-node-protocol-usage": [
+      "error",
+      "always"
+    ],
+    "unused-imports/no-unused-imports": "error",
+    "@stylistic/arrow-parens": 2,
+    "@stylistic/brace-style": 2,
+    "@stylistic/comma-dangle": 2,
+    "@stylistic/comma-spacing": 2,
+    "@stylistic/dot-location": [
+      2,
+      "property"
+    ],
+    "@stylistic/func-call-spacing": 2,
+    "@stylistic/indent": [
+      "error",
+      2
+    ],
+    "@stylistic/indent-binary-ops": [
+      "error",
+      2
+    ],
+    "@stylistic/key-spacing": 2,
+    "@stylistic/keyword-spacing": 2,
+    "@stylistic/member-delimiter-style": 2,
+    "@stylistic/no-extra-parens": 2,
+    "@stylistic/no-extra-semi": 2,
+    "@stylistic/no-floating-decimal": 2,
+    "@stylistic/no-mixed-spaces-and-tabs": 2,
+    "@stylistic/no-multiple-empty-lines": [
+      2,
+      {
+        "max": 1
+      }
+    ],
+    "@stylistic/no-tabs": 2,
+    "@stylistic/no-trailing-spaces": 2,
+    "@stylistic/no-whitespace-before-property": 2,
+    "@stylistic/nonblock-statement-body-position": 2,
+    "@stylistic/operator-linebreak": [
+      2,
+      "before"
+    ],
+    "@stylistic/padding-line-between-statements": 2,
+    "@stylistic/quotes": [
+      "error",
+      "double"
+    ],
+    "@stylistic/semi": [
+      "error"
+    ],
+    "@stylistic/semi-spacing": 2,
+    "@stylistic/space-before-blocks": 2,
+    "@stylistic/space-in-parens": 2,
+    "@stylistic/space-infix-ops": 2,
+    "@stylistic/space-unary-ops": 2,
+    "@stylistic/spaced-comment": 2,
+    "@stylistic/template-curly-spacing": 2,
+    "@stylistic/type-annotation-spacing": 2,
+    "@stylistic/type-generic-spacing": 2,
+    "@stylistic/type-named-tuple-spacing": 2,
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        "varsIgnorePattern": "_+"
+      }
+    ],
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/ban-types": "off",
+    "arrow-spacing": "error",
+    "dot-notation": "error",
+    "eqeqeq": "error",
+    "no-alert": "error",
+    "no-const-assign": "error",
+    "no-multi-spaces": "error",
+    "no-multiple-empty-lines": "error",
+    "prefer-const": "error",
+    "quotes": [
+      "error",
+      "double",
+      {
+        "allowTemplateLiterals": true
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "maro-plugin-tasks",
+  "version": "1.0.0",
+  "main": "./dist/lib/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "build": "tsc --project ./tsconfig.json",
+    "start": "node ./dist/src/index.js",
+    "clean": "rm -rf node_modules package-lock.json"
+  },
+  "peerDependencies": {
+    "@maro/maro": "2.0.0"
+  },
+  "maro": {
+    "plugin": "./dist/src/index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@stylistic/eslint-plugin": "2.6.5",
+    "eslint": "8.57.1",
+    "eslint-plugin-de-morgan": "2.0.0",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-math": "0.13.1",
+    "eslint-plugin-promise": "7.2.1",
+    "eslint-plugin-unused-imports": "4.3.0"
+  }
+}

package/src/commands/open.ts

@@ -0,0 +1,16 @@
+import { getTasksFromDir } from "src/lib/utils";
+
+import { Command } from "@maro/maro";
+
+const OpenCommand: Command = {
+  name: "open",
+  description: "Open task from cwd in editor",
+  run: async ({ ctx }) => {
+    const tasks = getTasksFromDir(ctx.cwd);
+    const task = await ctx.ui.promptChoice(tasks, { message: "Choose task to open" });
+    task.openInEditor();
+  }
+};
+
+export default OpenCommand;
+

package/src/index.ts

@@ -0,0 +1,18 @@
+import OpenCommand from "./commands/open";
+import { PluginExport } from "../../../dist/lib";
+
+const plugin: PluginExport = {
+  name: "maro-plugin-tasks",
+  commands: [
+    {
+      name: "task",
+      description: "Track tasks asociated with TODOS",
+      aliases: [],
+      subcommands: [
+        OpenCommand
+      ]
+    }
+  ]
+};
+
+export default plugin;

package/src/lib/action.ts

@@ -0,0 +1,32 @@
+import { Action, ActionRegistry, loading, MrCreateEvent } from "@maro/maro";
+
+import { TaskTracker } from "./tracker";
+import { getTasksFromDir } from "./utils";
+
+export class CreateMissingTasksAction implements Action {
+  tracker: TaskTracker;
+
+  constructor(tracker: TaskTracker) {
+    this.tracker = tracker;
+  }
+
+  register(): void {
+    ActionRegistry.on(MrCreateEvent, (event) => this.execute(event));
+  }
+
+  @loading("Generating missing issues")
+  async execute(event: MrCreateEvent) {
+    const repo = event.ctx;
+    const tasks = getTasksFromDir(repo.dir);
+
+    await Promise.all(
+      tasks.map(async (t) => {
+        if (this.tracker.isTracked(t)) return;
+        await this.tracker.track(t);
+        await repo.add(t.file_location.file);
+      }));
+    await repo.commit("fix: add issues");
+  }
+
+}
+

package/src/lib/index.ts

@@ -0,0 +1,3 @@
+export { CreateMissingTasksAction } from "./action";
+export { Task } from "./task";
+export { TaskTracker } from "./tracker";

package/src/lib/repo_task_tracker.ts

@@ -0,0 +1,175 @@
+import { Repo } from "@maro/maro";
+
+import { Task } from "./task";
+import { TaskTracker } from "./tracker";
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export const TASK_FILE = "TASK.md";
+
+// TODO: for now Tasks change status manually outside the app,
+// add support for trackers to change task status, could be useful for RepoActions
+const TASK_STATUS = {
+  OPEN: "OPEN",
+  CLOSED: "CLOSED"
+} as const;
+
+export class RepoTaskTracker extends TaskTracker {
+  repo: Repo;
+
+  constructor(repo: Repo) {
+    super();
+    this.repo = repo;
+  }
+
+  override addIdToTodo(id: string): string {
+    return `(${id})`;
+  }
+
+  override async save(task: Task): Promise<string> {
+    const d = new Date();
+    const pad = (n: number) => String(n).padStart(2, "0");
+    const YYYY = d.getFullYear();
+    const MM = pad(d.getMonth() + 1);
+    const DD = pad(d.getDate());
+    const HH = pad(d.getHours());
+    const mm = pad(d.getMinutes());
+    const SS = pad(d.getSeconds());
+    await sleep(1 * 1000);
+    const id = `${YYYY}${MM}${DD}-${HH}${mm}${SS}`;
+
+    const tasks_dir = this.repo.dir.sub("tasks");
+    tasks_dir.create();
+    const task_dir = tasks_dir.sub(id);
+    task_dir.createFile(TASK_FILE).write(this.toMdString(task));
+    return id;
+  }
+
+  override isTracked(task: Task): boolean {
+    const todoLine = task.getTodo();
+    const regex = /TODO[^:]*\([^)]*\)[^:]*:/;
+    return regex.test(todoLine);
+  }
+
+  private toMdString(task: Task) {
+    const relative = task.getPathInProject();
+    return `# ${task.title}
+
+  - PROJECT: ${task.project}
+  - FILE-LOCATION: ${relative}:${task.file_location.row}:${task.file_location.col}
+  - STATUS: ${TASK_STATUS.OPEN}
+
+${task.description} `;
+  }
+
+  // async getTasks(project?: string) {
+  //   await this.update();
+  //   const dirs = project ? [project] : readdirs(this.full_path).map((d) => d.name);
+  //   const full_dirs = dirs.map((d) => path.join(this.full_path, d));
+  //   return full_dirs.flatMap((d) => readdirs(d).map((task_dir) => Task.fromTaskFile(path.join(d, task_dir.name, TASK_FILE))));
+  // }
+  //
+  // addTask(task: Task) {
+  //   const dir = path.join(this.full_path, task.project, task.id);
+  //   const task_path = path.join(dir, TASK_FILE);
+  //   createDirIfNotExists(dir);
+  //   task.save(task_path);
+  // }
+
+  // TODO: move to TaskRepo
+  // private static parseFileLocation(raw: string): FileLocation {
+  //   const [file_path, row, col] = raw.split(":");
+  //   if (!file_path) throw new Error(`Could not parse file location ${raw} file_path missing`);
+  //   return { file_path, row: Number(row), col: Number(col) };
+  // }
+
+  // TODO: move to TaskRepo
+  // static fromTaskFile(file: string) {
+  //   const raw = fs.readFileSync(file, "utf8");
+  //
+  //   const tree = fromMarkdown(raw);
+  //
+  //   let title: string | undefined;
+  //   let id: string | undefined;
+  //   let project: string | undefined;
+  //   let status: TaskStatus | undefined;
+  //   let priority: number | undefined;
+  //   let fileLocation: FileLocation | undefined;
+  //   let jiraId: string | undefined;
+  //   let description = "";
+  //
+  //   for (const node of tree.children) {
+  //     if (node.type === "heading" && node.depth === 1) {
+  //       if (!node.children[0] || !("value" in node.children[0])) continue;
+  //       title = node.children[0]?.value.trim();
+  //       continue;
+  //     }
+  //
+  //     if (node.type === "list") {
+  //       for (const item of node.children) {
+  //         if (!item.children[0]
+  //           || !("children" in item.children[0])
+  //           || !item.children[0].children[0]
+  //           || !("value" in item.children[0].children[0])) continue;
+  //         const text = item.children[0].children[0]?.value;
+  //         const [key, rawVal, ...rest] = text.split(":");
+  //         const value = [rawVal, ...rest].join(":")?.trim();
+  //         switch (key) {
+  //           case "ID":
+  //             id = value;
+  //             break;
+  //           case "PROJECT":
+  //             project = value;
+  //             break;
+  //           case "STATUS": {
+  //             const statuses = Object.values(TASK_STATUS);
+  //             if (!statuses.includes(value as TaskStatus)) throw new Error(`Invalid STATUS "${value}". Must be one of: ${statuses.join(", ")}`);
+  //             status = value as TaskStatus;
+  //             break;
+  //           }
+  //           case "PRIORITY":
+  //             priority = Number(value);
+  //             break;
+  //           case "JIRA-ID":
+  //             jiraId = value;
+  //             break;
+  //           case "FILE-LOCATION":
+  //             fileLocation = this.parseFileLocation(value ?? "");
+  //             break;
+  //         }
+  //       }
+  //       continue;
+  //     }
+  //
+  //     if (node.type === "paragraph") {
+  //       const text = node.children.map((c) => {
+  //         if (!("value" in c)) return "";
+  //         return c.value;
+  //       }).join("").trim();
+  //       if (text) description += (description ? "\n" : "") + text;
+  //     }
+  //   }
+  //
+  //   if (!id) throw new Error(`Could not find id for task ${file}`);
+  //   if (!project) throw new Error(`Could not find project for task ${file}`);
+  //   if (!title) throw new Error(`Could not find title for task ${id} from project ${project}`);
+  //   if (!priority) throw new Error(`Could not find priority for task ${id} from project ${project}`);
+  //   if (!status) throw new Error(`Could not find status for task ${id} from project ${project}`);
+  //
+  //   return new Task({
+  //     md_path: file,
+  //     id,
+  //     title,
+  //     project,
+  //     description,
+  //     tags: {
+  //       status,
+  //       priority,
+  //       jira_id: jiraId,
+  //       file_location: fileLocation
+  //     }
+  //   });
+  // }
+}

package/src/lib/task.ts

@@ -0,0 +1,77 @@
+import {
+  Choice,
+  Dir,
+  openInEditor,
+  TextFile
+} from "@maro/maro";
+
+type FileLocation = {
+  file: TextFile;
+  row: number;
+  col: number;
+};
+
+export class Task {
+  project: Dir;
+
+  title: string;
+  description?: string;
+  file_location: FileLocation;
+
+  constructor({ title, file_location, project, description }: {
+    description?: string;
+    project: Dir;
+    title: string;
+    file_location: FileLocation;
+  }) {
+    const file = file_location.file;
+    if (!project.contains(file)) throw new Error(`${file} is not in ${project}`);
+    this.title = title;
+    this.file_location = file_location;
+    this.project = project;
+    this.description = description;
+  }
+
+  getTodo() {
+    const { file, row } = this.file_location;
+    const lines = file.read().split(/\r?\n/);
+    const normalized_row = row - 1;
+    return lines[normalized_row]!;
+  }
+
+  editTodo(add: string) {
+    const todoLine = this.getTodo();
+    const { file, col, row } = this.file_location;
+    const normalized_row = row - 1;
+    const normalized_col = col - 1;
+
+    const prefix = todoLine.slice(0, normalized_col);
+    const afterTodo = todoLine.slice(normalized_col);
+    const colonIndex = afterTodo.indexOf(":");
+
+    const originalDecorations = colonIndex === -1
+      ? afterTodo.slice("TODO".length)
+      : afterTodo.slice("TODO".length, colonIndex);
+
+    const originalBody = colonIndex === -1 ? "" : afterTodo.slice(colonIndex + 1).trim();
+
+    const newTodo = prefix + "TODO" + originalDecorations + add + ": " + originalBody;
+    const lines = file.read().split(/\r?\n/);
+    lines[normalized_row] = newTodo;
+    file.write(lines.join("\n"));
+  }
+
+  openInEditor() {
+    const { col, row } = this.file_location;
+    openInEditor(this.file_location.file, { line: row, column: col });
+  }
+
+  getPathInProject() {
+    return this.project.relativePathTo(this.file_location.file);
+  }
+
+  toChoice(): Choice {
+    return { name: this.title, hint: `${this.file_location.file}:${this.file_location.row}:${this.file_location.col}` };
+  }
+
+}

package/src/lib/tracker.ts

@@ -0,0 +1,15 @@
+import { Task } from "./task";
+
+export abstract class TaskTracker {
+
+  abstract save(task: Task): Promise<string>;
+  abstract addIdToTodo(id: string, task: Task): string;
+  abstract isTracked(task: Task): boolean;
+
+  async track(task: Task) {
+    if (this.isTracked(task)) return;
+    const id = await this.save(task);
+    task.editTodo(this.addIdToTodo(id, task) ?? "");
+  }
+}
+

package/src/lib/utils.ts

@@ -0,0 +1,29 @@
+import { Dir, TextFile } from "@maro/maro";
+
+import { Task } from "./task";
+
+export const getTasksFromDir = (dir: Dir) => {
+  const files = dir.traverse();
+  const tasks: Task[] = [];
+  for (const f of files) tasks.push(...getTasksFromFile(dir, f));
+  return tasks;
+};
+
+export const getTasksFromFile = (project: Dir, fileInDir: TextFile) => {
+  const lines = fileInDir.read().split(/\r?\n/);
+  const results: Task[] = [];
+  const regex = /TODO.*:\s*(.*)/g;
+  for (let row = 0; row < lines.length; row++) {
+    const line = lines[row]!;
+    let match;
+    while ((match = regex.exec(line)) !== null) {
+      const col = match.index;
+      const title = match[1]?.trim() ?? "";
+      const file_location = { file: fileInDir, row: row + 1, col: col + 1 };
+      // TODO: Task.description from file
+      results.push(new Task({ title, project, file_location }));
+    }
+  }
+  return results;
+};
+

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "es2021",
+      "dom"
+    ],
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": "./",
+    "baseUrl": "./",
+    "strict": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "useUnknownInCatchVariables": true,
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false,
+    "noUncheckedIndexedAccess": true,
+    "noEmit": false,
+    "noEmitOnError": false
+  }
+}