taskin 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/index.js

@@ -1,38 +1,1385 @@
 #!/usr/bin/env node
-/**
- * Taskin CLI - Main entry point
- * Command-line interface for managing tasks
- */
-import { Command } from 'commander';
-import { finishCommand } from './commands/finish.js';
-import { initCommand } from './commands/init.js';
-import { lintCommand } from './commands/lint.js';
-import { listCommand } from './commands/list.js';
-import { pauseCommand } from './commands/pause.js';
-import { startCommand } from './commands/start.js';
-import { showCustomHelp } from './lib/help.js';
-const program = new Command();
-program
-  .name('taskin')
-  .description('🚀 Task Management System')
-  .version('0.1.0')
-  .configureHelp({
-    formatHelp: () => showCustomHelp(),
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// ../../node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+import { Command } from "commander";
+
+// src/commands/finish.ts
+init_esm_shims();
+
+// ../fs-task-provider/src/index.ts
+init_esm_shims();
+
+// ../fs-task-provider/src/fs-task-provider.ts
+init_esm_shims();
+import { promises as fs } from "fs";
+import path2 from "path";
+var FileSystemTaskProvider = class {
+  constructor(tasksDirectory) {
+    this.tasksDirectory = tasksDirectory;
+  }
+  async findTask(taskId) {
+    const files = await fs.readdir(this.tasksDirectory);
+    const taskFile = files.find(
+      (file) => file.startsWith(`task-${taskId}-`) && file.endsWith(".md")
+    );
+    if (!taskFile) {
+      return void 0;
+    }
+    const filePath = path2.join(this.tasksDirectory, taskFile);
+    const content = await fs.readFile(filePath, "utf-8");
+    const titleMatch = content.match(/^# Task \d+ - (.+)$/m);
+    const title = titleMatch ? titleMatch[1] : "Untitled";
+    const task = {
+      id: taskId,
+      title,
+      content,
+      filePath,
+      userId: "unknown",
+      status: "pending",
+      type: "feat",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return task;
+  }
+  async updateTask(task) {
+    await fs.writeFile(task.filePath, task.content);
+  }
+  async getAllTasks() {
+    const files = await fs.readdir(this.tasksDirectory);
+    const taskFiles = files.filter(
+      (file) => file.startsWith("task-") && file.endsWith(".md")
+    );
+    const tasks = [];
+    for (const file of taskFiles) {
+      const filePath = path2.join(this.tasksDirectory, file);
+      const content = await fs.readFile(filePath, "utf-8");
+      const idMatch = file.match(/^task-(\d+)-/);
+      const taskId = idMatch ? idMatch[1] : "unknown";
+      const titleMatch = content.match(/^# .*Task.*?[—-]\s*(.+)$/im);
+      const title = titleMatch ? titleMatch[1].trim() : "Untitled";
+      const headerSection = content.split(/^##/m)[0];
+      const statusMatch = headerSection.match(/^Status:\s*(.+)$/im);
+      const typeMatch = headerSection.match(/^Type:\s*(.+)$/im);
+      const userMatch = headerSection.match(/^Assignee:\s*(.+)$/im);
+      const task = {
+        id: taskId,
+        title,
+        content,
+        filePath,
+        userId: userMatch ? userMatch[1].trim() : void 0,
+        status: statusMatch ? statusMatch[1].trim().toLowerCase() : "pending",
+        type: typeMatch ? typeMatch[1].trim().toLowerCase() : "feat",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      tasks.push(task);
+    }
+    return tasks;
+  }
+};
+
+// ../task-manager/src/index.ts
+init_esm_shims();
+
+// ../task-manager/src/task-manager.ts
+init_esm_shims();
+var TaskManager = class {
+  constructor(taskProvider) {
+    this.taskProvider = taskProvider;
+  }
+  async startTask(taskId) {
+    const task = await this.taskProvider.findTask(taskId);
+    if (!task) {
+      throw new Error(`Task with ID '${taskId}' not found.`);
+    }
+    if (task.status === "in-progress") {
+      throw new Error(`Task '${taskId}' is already in progress.`);
+    }
+    if (task.status === "done") {
+      throw new Error(`Task '${taskId}' is already done.`);
+    }
+    const updatedTask = { ...task, status: "in-progress" };
+    await this.taskProvider.updateTask(updatedTask);
+    return updatedTask;
+  }
+  async finishTask(taskId) {
+    const task = await this.taskProvider.findTask(taskId);
+    if (!task) {
+      throw new Error(`Task with ID '${taskId}' not found.`);
+    }
+    const updatedTask = { ...task, status: "done" };
+    await this.taskProvider.updateTask(updatedTask);
+    return updatedTask;
+  }
+};
+
+// ../task-manager/src/task-manager.mock.ts
+init_esm_shims();
+
+// ../task-manager/src/task-manager.types.ts
+init_esm_shims();
+
+// src/commands/finish.ts
+import path3 from "path";
+
+// src/lib/colors.ts
+init_esm_shims();
+import chalk from "chalk";
+var colors = {
+  info: chalk.cyan,
+  success: chalk.green,
+  warning: chalk.yellow,
+  error: chalk.red,
+  highlight: chalk.bold.white,
+  secondary: chalk.gray,
+  normal: chalk.white
+};
+var icons = {
+  rocket: "\u{1F680}",
+  list: "\u{1F4CA}",
+  check: "\u2705",
+  pause: "\u23F8\uFE0F",
+  info: "\u{1F4A1}",
+  task: "\u{1F4CB}",
+  gear: "\u2699\uFE0F"
+};
+function printHeader(title, icon) {
+  console.log();
+  console.log(colors.highlight("\u2550".repeat(60)));
+  console.log(colors.highlight(`${icon}  ${title}`));
+  console.log(colors.highlight("\u2550".repeat(60)));
+  console.log();
+}
+function success(message) {
+  console.log(colors.success(`\u2713 ${message}`));
+}
+function error(message) {
+  console.error(colors.error(`\u2717 ${message}`));
+}
+function info(message) {
+  console.log(colors.info(`\u2139 ${message}`));
+}
+
+// src/commands/define-command/index.ts
+init_esm_shims();
+
+// src/commands/define-command/define-command.ts
+init_esm_shims();
+var defineCommand = (config) => {
+  return (program2) => {
+    const cmd = program2.command(config.name).description(config.description);
+    if (config.alias) {
+      cmd.alias(config.alias);
+    }
+    config.options?.forEach((opt) => {
+      cmd.option(opt.flags, opt.description, opt.defaultValue);
+    });
+    cmd.action(async (...args) => {
+      try {
+        await config.handler(...args);
+      } catch (err) {
+        error(
+          `Failed to execute command: ${err instanceof Error ? err.message : String(err)}`
+        );
+        process.exit(1);
+      }
+    });
+  };
+};
+
+// src/commands/define-command/define-command.types.ts
+init_esm_shims();
+
+// src/commands/finish.ts
+var finishCommand = defineCommand({
+  name: "finish <task-id>",
+  description: "\u2705 Complete a task",
+  alias: "done",
+  options: [
+    {
+      flags: "-s, --skip-update",
+      description: "Skip updating task status"
+    }
+  ],
+  handler: async (taskId, options) => {
+    await finishTask(taskId, options);
+  }
+});
+async function finishTask(taskId, options) {
+  printHeader(`Finishing Task ${taskId}`, "\u2705");
+  const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
+  const tasksDir = path3.join(process.cwd(), "TASKS");
+  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const taskManager = new TaskManager(taskProvider);
+  const task = await taskProvider.findTask(normalizedId);
+  if (!task) {
+    error(`Task ${normalizedId} not found in TASKS/ directory`);
+    process.exit(1);
+  }
+  info(`Found task: ${task.title}`);
+  info(`Current status: ${task.status}`);
+  if (task.status === "done") {
+    error("Task is already done");
+    process.exit(1);
+  }
+  if (!options.skipUpdate) {
+    info("Marking task as done...");
+    const updatedTask = await taskManager.finishTask(task.id);
+    success(`Task ${updatedTask.id} completed successfully! \u{1F389}`);
+    success(`Status changed to: ${updatedTask.status}`);
+  } else {
+    info("Skipping status update (--skip-update flag)");
+  }
+  console.log();
+  info("Suggested commit message:");
+  const commitType = task.type || "feat";
+  console.log(
+    colors.highlight(`  ${commitType}(task-${normalizedId}): ${task.title}`)
+  );
+  console.log();
+  info("Next steps:");
+  console.log(colors.secondary("  1. Review your changes"));
+  console.log(colors.secondary("  2. Commit: git add . && git commit"));
+  console.log(colors.secondary("  3. Push: git push"));
+  console.log(colors.secondary("  4. Create a Pull Request"));
+  console.log();
+  success("Great work! \u{1F680}");
+  console.log();
+}
+
+// src/commands/init.ts
+init_esm_shims();
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import inquirer from "inquirer";
+import { join } from "path";
+
+// src/lib/provider-installer/index.ts
+init_esm_shims();
+
+// src/lib/provider-installer/provider-installer.ts
+init_esm_shims();
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+function detectPackageManager() {
+  if (existsSync("pnpm-lock.yaml")) {
+    return "pnpm";
+  }
+  if (existsSync("yarn.lock")) {
+    return "yarn";
+  }
+  return "npm";
+}
+function isProviderInstalled(packageName) {
+  try {
+    __require.resolve(packageName);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installProvider(provider) {
+  const packageManager = detectPackageManager();
+  const { packageName } = provider;
+  console.log(`
+\u{1F4E6} Installing ${packageName}...`);
+  try {
+    let command;
+    switch (packageManager) {
+      case "pnpm":
+        command = `pnpm add ${packageName}`;
+        break;
+      case "yarn":
+        command = `yarn add ${packageName}`;
+        break;
+      default:
+        command = `npm install ${packageName}`;
+    }
+    execSync(command, { stdio: "inherit" });
+    console.log(`\u2705 ${packageName} installed successfully!
+`);
+  } catch (error2) {
+    console.error(`
+\u274C Failed to install ${packageName}`);
+    throw error2;
+  }
+}
+async function loadProvider(packageName) {
+  try {
+    const module = await import(packageName);
+    return module.default || module;
+  } catch (error2) {
+    console.error(`Failed to load provider: ${packageName}`);
+    throw error2;
+  }
+}
+async function ensureProviderInstalled(provider) {
+  const { packageName } = provider;
+  if (!isProviderInstalled(packageName)) {
+    console.log(`
+\u26A0\uFE0F  Provider ${packageName} is not installed.`);
+    installProvider(provider);
+  }
+  return loadProvider(packageName);
+}
+
+// src/lib/provider-installer/provider-installer.types.ts
+init_esm_shims();
+
+// src/lib/provider-registry/index.ts
+init_esm_shims();
+
+// src/lib/provider-registry/provider-registry.ts
+init_esm_shims();
+var AVAILABLE_PROVIDERS = [
+  {
+    id: "fs",
+    name: "\u{1F4C1} File System",
+    description: "Store tasks as Markdown files in a local TASKS/ directory",
+    packageName: "@opentask/taskin-fs-provider",
+    configSchema: {
+      required: ["tasksDir"],
+      properties: {
+        tasksDir: {
+          type: "string",
+          description: "Directory to store task files"
+        }
+      }
+    },
+    status: "stable"
+  },
+  {
+    id: "redmine",
+    name: "\u{1F534} Redmine",
+    description: "Sync tasks with Redmine issues via REST API",
+    packageName: "@opentask/taskin-redmine-provider",
+    configSchema: {
+      required: ["apiUrl", "apiKey", "projectId"],
+      properties: {
+        apiUrl: {
+          type: "string",
+          description: "Redmine server URL (e.g., https://redmine.example.com)"
+        },
+        apiKey: {
+          type: "string",
+          description: "Your Redmine API key",
+          secret: true
+        },
+        projectId: {
+          type: "string",
+          description: "Project identifier or ID"
+        }
+      }
+    },
+    status: "coming-soon"
+  },
+  {
+    id: "jira",
+    name: "\u{1F535} Jira",
+    description: "Sync tasks with Jira issues via REST API",
+    packageName: "@opentask/taskin-jira-provider",
+    configSchema: {
+      required: ["apiUrl", "email", "apiToken", "projectKey"],
+      properties: {
+        apiUrl: {
+          type: "string",
+          description: "Jira server URL (e.g., https://company.atlassian.net)"
+        },
+        email: {
+          type: "string",
+          description: "Your Atlassian account email"
+        },
+        apiToken: {
+          type: "string",
+          description: "Your Jira API token",
+          secret: true
+        },
+        projectKey: {
+          type: "string",
+          description: "Project key (e.g., PROJ)"
+        }
+      }
+    },
+    status: "coming-soon"
+  },
+  {
+    id: "github",
+    name: "\u{1F419} GitHub Issues",
+    description: "Sync tasks with GitHub Issues",
+    packageName: "@opentask/taskin-github-provider",
+    configSchema: {
+      required: ["owner", "repo", "token"],
+      properties: {
+        owner: {
+          type: "string",
+          description: "Repository owner (username or organization)"
+        },
+        repo: {
+          type: "string",
+          description: "Repository name"
+        },
+        token: {
+          type: "string",
+          description: "GitHub Personal Access Token",
+          secret: true
+        }
+      }
+    },
+    status: "coming-soon"
+  }
+];
+function getProviderById(id) {
+  return AVAILABLE_PROVIDERS.find((p) => p.id === id);
+}
+function getAllProviders() {
+  return AVAILABLE_PROVIDERS;
+}
+
+// src/lib/provider-registry/provider-registry.types.ts
+init_esm_shims();
+
+// src/commands/init.ts
+var initCommand = defineCommand({
+  name: "init",
+  alias: "setup",
+  description: "\u{1F3AF} Initialize Taskin in your project",
+  options: [
+    {
+      flags: "-f, --force",
+      description: "Force initialization (overwrite existing configuration)"
+    }
+  ],
+  handler: async (options) => {
+    await initializeTaskin(options);
+  }
+});
+async function initializeTaskin(options) {
+  printHeader("Initializing Taskin", "\u{1F3AF}");
+  const cwd = process.cwd();
+  const configFile = join(cwd, ".taskin.json");
+  if (existsSync2(configFile) && !options.force) {
+    error("Taskin is already initialized in this project");
+    info("Use --force to reinitialize");
+    process.exit(1);
+  }
+  const allProviders = getAllProviders();
+  const choices = allProviders.map((p) => {
+    const installed = isProviderInstalled(p.packageName);
+    const status = p.status === "coming-soon" ? " (coming soon)" : "";
+    const installedMark = installed ? " \u2713" : "";
+    return {
+      name: `${p.name}${installedMark}${status} - ${p.description}`,
+      value: p.id,
+      disabled: p.status === "coming-soon" ? "Not yet implemented" : false
+    };
   });
-// Register commands
+  const { providerId } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "providerId",
+      message: "Select a task provider:",
+      choices,
+      default: "fs"
+    }
+  ]);
+  const selectedProvider = getProviderById(providerId);
+  if (!selectedProvider) {
+    error(`Provider "${providerId}" not found`);
+    process.exit(1);
+  }
+  console.log();
+  info(`Setting up task provider: ${colors.highlight(selectedProvider.name)}`);
+  console.log();
+  await ensureProviderInstalled(selectedProvider);
+  const providerConfig = await setupProviderConfig(selectedProvider, cwd);
+  const config = {
+    version: "0.1.0",
+    provider: {
+      type: selectedProvider.id,
+      config: providerConfig
+    }
+  };
+  info("Creating configuration file...");
+  writeFileSync(configFile, JSON.stringify(config, null, 2), "utf-8");
+  success(`\u2713 Created ${colors.highlight(".taskin.json")}`);
+  const gitignorePath = join(cwd, ".gitignore");
+  if (existsSync2(gitignorePath)) {
+    const gitignoreContent = __require("fs").readFileSync(gitignorePath, "utf-8");
+    if (!gitignoreContent.includes(".taskin.json")) {
+      info("Adding .taskin.json to .gitignore...");
+      writeFileSync(
+        gitignorePath,
+        `${gitignoreContent}
+# Taskin configuration
+.taskin.json
+`,
+        "utf-8"
+      );
+      success("\u2713 Updated .gitignore");
+    }
+  }
+  console.log();
+  success("\u{1F389} Taskin initialized successfully!");
+  console.log();
+  info("Next steps:");
+  console.log(colors.secondary("  1. Run: taskin list"));
+  console.log(
+    colors.secondary(
+      selectedProvider.id === "fs" ? "  2. Edit or create tasks in TASKS/" : `  2. Tasks will be synced with ${selectedProvider.name}`
+    )
+  );
+  console.log(colors.secondary("  3. Start working: taskin start <task-id>"));
+  console.log();
+  info("For more information, run: taskin --help");
+  console.log();
+}
+async function setupProviderConfig(provider, cwd) {
+  if (provider.id === "fs") {
+    return setupFileSystemProvider(cwd);
+  }
+  info(`Configuring ${provider.name}...`);
+  console.log();
+  const questions = Object.entries(provider.configSchema.properties).map(
+    ([key, schema]) => ({
+      type: schema.secret ? "password" : "input",
+      name: key,
+      message: `${schema.description}:`,
+      validate: (input) => {
+        if (provider.configSchema.required.includes(key) && input.length === 0) {
+          return `${schema.description} is required`;
+        }
+        return true;
+      }
+    })
+  );
+  const answers = await inquirer.prompt(questions);
+  console.log();
+  success(`\u2713 ${provider.name} configuration saved`);
+  return answers;
+}
+async function setupFileSystemProvider(cwd) {
+  const tasksDir = join(cwd, "TASKS");
+  if (!existsSync2(tasksDir)) {
+    info(`Creating TASKS directory...`);
+    mkdirSync(tasksDir, { recursive: true });
+    success(`\u2713 Created ${colors.highlight("TASKS/")} directory`);
+  } else {
+    info(`${colors.highlight("TASKS/")} directory already exists`);
+  }
+  const sampleTaskFile = join(tasksDir, "task-001-setup-project.md");
+  if (!existsSync2(sampleTaskFile)) {
+    info("Creating sample task...");
+    const sampleTask = `# Task 001 \u2014 Setup Project
+
+Status: pending
+Type: chore
+Assignee: developer
+
+## Description
+
+This is a sample task created during Taskin initialization.
+
+## Tasks
+
+- [ ] Review Taskin documentation
+- [ ] Create your first task
+- [ ] Start working on a task
+
+## Notes
+
+You can edit or delete this file. Use \`taskin list\` to see all tasks.
+`;
+    writeFileSync(sampleTaskFile, sampleTask, "utf-8");
+    success(
+      `\u2713 Created sample task ${colors.highlight("task-001-setup-project.md")}`
+    );
+  }
+  return {
+    tasksDir: "TASKS"
+  };
+}
+
+// src/commands/lint.ts
+init_esm_shims();
+import { join as join3 } from "path";
+
+// src/lib/file-system-task-linter/index.ts
+init_esm_shims();
+
+// src/lib/file-system-task-linter/file-system-task-linter.ts
+init_esm_shims();
+import chalk2 from "chalk";
+import { readdir, readFile } from "fs/promises";
+import { join as join2 } from "path";
+var VALID_STATUSES = ["pending", "in-progress", "done", "blocked"];
+var VALID_TYPES = ["feat", "fix", "chore", "docs", "refactor", "test"];
+var FileSystemTaskLinter = class {
+  errors = [];
+  addError(file, message, severity = "error", line) {
+    this.errors.push({ file, message, severity, line });
+  }
+  /**
+   * Validate task file name format (FileSystem-specific)
+   */
+  validateFileName(fileName) {
+    const pattern = /^task-\d{2,3}-[a-z0-9-]+\.md$/;
+    if (!pattern.test(fileName)) {
+      return {
+        file: fileName,
+        message: "Invalid filename. Expected: task-NNN-kebab-case-title.md",
+        severity: "error"
+      };
+    }
+    return null;
+  }
+  extractMetadata(content) {
+    const headerSection = content.split(/^##/m)[0];
+    const statusMatch = headerSection.match(/^Status:\s*(.+)$/im);
+    const typeMatch = headerSection.match(/^Type:\s*(.+)$/im);
+    const assigneeMatch = headerSection.match(/^Assignee:\s*(.+)$/im);
+    return {
+      status: statusMatch?.[1]?.trim().toLowerCase(),
+      type: typeMatch?.[1]?.trim().toLowerCase(),
+      assignee: assigneeMatch?.[1]?.trim()
+    };
+  }
+  /**
+   * Validate task metadata (FileSystem-specific)
+   */
+  validateMetadata(metadata, filePath) {
+    const errors = [];
+    if (!metadata.status) {
+      errors.push({
+        file: filePath,
+        message: "Missing required metadata: Status",
+        severity: "error"
+      });
+    } else if (!VALID_STATUSES.includes(metadata.status)) {
+      errors.push({
+        file: filePath,
+        message: `Invalid status "${metadata.status}". Valid: ${VALID_STATUSES.join(", ")}`,
+        severity: "error"
+      });
+    }
+    if (!metadata.type) {
+      errors.push({
+        file: filePath,
+        message: "Missing required metadata: Type",
+        severity: "error"
+      });
+    } else if (!VALID_TYPES.includes(metadata.type)) {
+      errors.push({
+        file: filePath,
+        message: `Invalid type "${metadata.type}". Valid: ${VALID_TYPES.join(", ")}`,
+        severity: "error"
+      });
+    }
+    if (!metadata.assignee) {
+      errors.push({
+        file: filePath,
+        message: "Missing recommended metadata: Assignee",
+        severity: "warning"
+      });
+    }
+    return errors;
+  }
+  validateContent(filename, content) {
+    const lines = content.split("\n");
+    if (!lines[0]?.trim().startsWith("# ")) {
+      this.addError(
+        filename,
+        "Task file must start with a level 1 heading (# Task NNN \u2014 Title)",
+        "error",
+        1
+      );
+    }
+    const h1Pattern = /^#\s+(?:🧩\s+)?Task\s+\d{2,3}\s+[—-]\s+.+$/i;
+    if (lines[0] && !h1Pattern.test(lines[0])) {
+      this.addError(
+        filename,
+        'H1 heading must follow format: "# Task NNN \u2014 Title"',
+        "error",
+        1
+      );
+    }
+    const metadata = this.extractMetadata(content);
+    const metadataErrors = this.validateMetadata(metadata, filename);
+    metadataErrors.forEach((error2) => {
+      this.addError(error2.file, error2.message, error2.severity, error2.line);
+    });
+    const h2Sections = content.match(/^##\s+.+$/gm);
+    if (!h2Sections || h2Sections.length === 0) {
+      this.addError(
+        filename,
+        "Task should have at least one section (## heading)",
+        "warning"
+      );
+    }
+    const firstH2Index = content.indexOf("\n##");
+    if (firstH2Index > -1) {
+      const afterH2 = content.substring(firstH2Index);
+      if (afterH2.match(/^Status:/im) || afterH2.match(/^Type:/im) || afterH2.match(/^Assignee:/im)) {
+        this.addError(
+          filename,
+          "Metadata must be placed BEFORE the first ## section",
+          "error"
+        );
+      }
+    }
+  }
+  /**
+   * Lint a single task file (FileSystem-specific)
+   */
+  async lintFile(filePath) {
+    const errors = [];
+    const fileName = filePath.split("/").pop() || filePath;
+    const fileNameError = this.validateFileName(fileName);
+    if (fileNameError) {
+      errors.push(fileNameError);
+    }
+    try {
+      const content = await readFile(filePath, "utf-8");
+      this.errors = [];
+      this.validateContent(fileName, content);
+      errors.push(...this.errors);
+    } catch (error2) {
+      errors.push({
+        file: fileName,
+        message: `Failed to read file: ${error2}`,
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  /**
+   * Lint all task files in the specified directory (FileSystem-specific)
+   */
+  async lintDirectory(tasksDir) {
+    this.errors = [];
+    try {
+      const files = await readdir(tasksDir);
+      const taskFiles = files.filter((f) => f.endsWith(".md"));
+      for (const file of taskFiles) {
+        const fileNameError = this.validateFileName(file);
+        if (fileNameError) {
+          this.addError(file, fileNameError.message, fileNameError.severity);
+        }
+        const content = await readFile(join2(tasksDir, file), "utf-8");
+        this.validateContent(file, content);
+      }
+      const errors = this.errors.filter((e) => e.severity === "error");
+      const warnings = this.errors.filter((e) => e.severity === "warning");
+      return {
+        errors,
+        warnings,
+        filesChecked: taskFiles.length,
+        valid: errors.length === 0
+      };
+    } catch (error2) {
+      throw new Error(`Failed to lint tasks: ${error2}`);
+    }
+  }
+  static printResults(result) {
+    if (result.errors.length === 0 && result.warnings.length === 0) {
+      console.log(
+        chalk2.green(`\u2705 All ${result.filesChecked} task files are valid!
+`)
+      );
+      return;
+    }
+    console.log(
+      chalk2.bold(
+        `
+\u{1F4CA} Validation Results (${result.filesChecked} files checked):
+`
+      )
+    );
+    const errorsByFile = /* @__PURE__ */ new Map();
+    [...result.errors, ...result.warnings].forEach((error2) => {
+      if (!errorsByFile.has(error2.file)) {
+        errorsByFile.set(error2.file, []);
+      }
+      errorsByFile.get(error2.file).push(error2);
+    });
+    for (const [file, fileErrors] of errorsByFile) {
+      console.log(chalk2.cyan(`
+\u{1F4C4} ${file}`));
+      for (const error2 of fileErrors) {
+        const icon = error2.severity === "error" ? chalk2.red("\u274C") : chalk2.yellow("\u26A0\uFE0F");
+        const location = error2.line ? `:${error2.line}` : "";
+        console.log(`  ${icon} ${error2.message}${location}`);
+      }
+    }
+    console.log("\n" + "\u2500".repeat(60));
+    console.log(
+      chalk2.bold(
+        `
+\u{1F4CA} Summary: ${chalk2.red(result.errors.length + " error(s)")}, ${chalk2.yellow(result.warnings.length + " warning(s)")}
+`
+      )
+    );
+  }
+};
+
+// src/lib/file-system-task-linter/file-system-task-linter.mock.ts
+init_esm_shims();
+function createMockFileValidationError(overrides) {
+  return {
+    file: "task-001.md",
+    message: "Mock validation error",
+    severity: "error",
+    ...overrides
+  };
+}
+var MOCK_INVALID_LINT_RESULT = {
+  errors: [
+    createMockFileValidationError({
+      file: "task-001.md",
+      message: 'Invalid status: "invalid"'
+    }),
+    createMockFileValidationError({
+      file: "task-002.md",
+      message: 'Invalid type: "unknown"'
+    })
+  ],
+  filesChecked: 2,
+  valid: false,
+  warnings: []
+};
+var MOCK_WARNINGS_LINT_RESULT = {
+  errors: [],
+  filesChecked: 3,
+  valid: true,
+  warnings: [
+    createMockFileValidationError({
+      file: "task-003.md",
+      message: "Consider adding assignee",
+      severity: "warning"
+    })
+  ]
+};
+var MOCK_VALIDATION_ERRORS = [
+  createMockFileValidationError({
+    file: "task-001.md",
+    message: "Invalid status: must be one of [pending, in-progress, done, blocked]",
+    line: 5
+  }),
+  createMockFileValidationError({
+    file: "task-001.md",
+    message: "Invalid type: must be one of [feat, fix, chore, docs, refactor, test]",
+    line: 6
+  })
+];
+
+// src/lib/file-system-task-linter/file-system-task-linter.types.ts
+init_esm_shims();
+
+// src/commands/lint.ts
+var lintCommand = defineCommand({
+  name: "lint",
+  description: "\u{1F50D} Validate task markdown files",
+  options: [
+    {
+      flags: "-p, --path <directory>",
+      description: "Path to TASKS directory",
+      defaultValue: "TASKS"
+    }
+  ],
+  handler: async (options) => {
+    await executeLint(options);
+  }
+});
+async function executeLint(options) {
+  const tasksDir = options.path || join3(process.cwd(), "TASKS");
+  console.log(`\u{1F4CB} Linting task files in: ${tasksDir}
+`);
+  const linter = new FileSystemTaskLinter();
+  const result = await linter.lintDirectory(tasksDir);
+  FileSystemTaskLinter.printResults(result);
+  if (!result.valid) {
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+init_esm_shims();
+import path4 from "path";
+var listCommand = defineCommand({
+  name: "list [filter]",
+  description: "\u{1F4CA} List all tasks in the project",
+  alias: "ls",
+  options: [
+    {
+      flags: "-s, --status <status>",
+      description: "Filter by status (pending, in-progress, done, blocked)"
+    },
+    {
+      flags: "-t, --type <type>",
+      description: "Filter by type (feat, fix, refactor, docs, test, chore)"
+    },
+    {
+      flags: "-u, --user <user>",
+      description: "Filter by user"
+    }
+  ],
+  handler: async (filter, options) => {
+    await listTasks(filter, options);
+  }
+});
+async function listTasks(filter, options) {
+  printHeader("Task List", "\u{1F4CA}");
+  const tasksDir = path4.join(process.cwd(), "TASKS");
+  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const tasks = await taskProvider.getAllTasks();
+  if (tasks.length === 0) {
+    console.log(colors.warning("No tasks found in TASKS/ directory"));
+    return;
+  }
+  let filteredTasks = tasks;
+  if (options.status) {
+    filteredTasks = filteredTasks.filter((t) => t.status === options.status);
+  }
+  if (options.type) {
+    filteredTasks = filteredTasks.filter((t) => t.type === options.type);
+  }
+  if (options.assignee) {
+    filteredTasks = filteredTasks.filter(
+      (t) => t.userId?.toLowerCase().includes(options.assignee.toLowerCase())
+    );
+  }
+  if (filter) {
+    const lowerFilter = filter.toLowerCase();
+    filteredTasks = filteredTasks.filter(
+      (t) => t.id.includes(lowerFilter) || t.title.toLowerCase().includes(lowerFilter) || t.status.toLowerCase().includes(lowerFilter) || t.userId?.toLowerCase().includes(lowerFilter)
+    );
+  }
+  if (filteredTasks.length === 0) {
+    console.log(colors.warning("No tasks match the filters"));
+    return;
+  }
+  console.log(
+    colors.highlight(
+      `${"ID".padEnd(15)} ${"Status".padEnd(15)} ${"Type".padEnd(12)} ${"User".padEnd(15)} ${"Title"}`
+    )
+  );
+  console.log(colors.secondary("\u2500".repeat(100)));
+  filteredTasks.forEach((task) => {
+    const statusColor = getStatusColor(task.status);
+    const typeColor = getTypeColor(task.type);
+    console.log(
+      `${colors.info(task.id.padEnd(15))} ${statusColor(task.status.padEnd(15))} ${typeColor(task.type.padEnd(12))} ${colors.secondary((task.userId || "unknown").padEnd(15))} ${colors.normal(task.title)}`
+    );
+  });
+  console.log();
+  console.log(colors.secondary("\u2500".repeat(100)));
+  const statusCounts = {
+    pending: filteredTasks.filter((t) => t.status === "pending").length,
+    "in-progress": filteredTasks.filter((t) => t.status === "in-progress").length,
+    done: filteredTasks.filter((t) => t.status === "done").length,
+    blocked: filteredTasks.filter((t) => t.status === "blocked").length
+  };
+  console.log(
+    colors.info(
+      `\u{1F4CA} Total: ${filteredTasks.length} tasks | \u23F3 Pending: ${statusCounts.pending} | \u{1F680} In Progress: ${statusCounts["in-progress"]} | \u2705 Done: ${statusCounts.done} | \u{1F6AB} Blocked: ${statusCounts.blocked}`
+    )
+  );
+  console.log();
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "pending":
+      return colors.secondary;
+    case "in-progress":
+      return colors.info;
+    case "done":
+      return colors.success;
+    case "blocked":
+      return colors.error;
+    default:
+      return colors.normal;
+  }
+}
+function getTypeColor(type) {
+  switch (type) {
+    case "feat":
+      return colors.success;
+    case "fix":
+      return colors.error;
+    case "refactor":
+      return colors.warning;
+    case "docs":
+      return colors.info;
+    case "test":
+      return colors.secondary;
+    case "chore":
+      return colors.normal;
+    default:
+      return colors.normal;
+  }
+}
+
+// src/commands/pause.ts
+init_esm_shims();
+import path5 from "path";
+var pauseCommand = defineCommand({
+  name: "pause <task-id>",
+  description: "\u23F8\uFE0F  Pause work on a task",
+  alias: "stop",
+  options: [
+    {
+      flags: "-m, --message <message>",
+      description: "Custom commit message"
+    },
+    {
+      flags: "-s, --skip-commit",
+      description: "Skip commit (just show what would be done)"
+    }
+  ],
+  handler: async (taskId, options) => {
+    await pauseTask(taskId, options);
+  }
+});
+async function pauseTask(taskId, options) {
+  printHeader(`Pausing Task ${taskId}`, "\u23F8\uFE0F");
+  const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
+  const tasksDir = path5.join(process.cwd(), "TASKS");
+  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const task = await taskProvider.findTask(normalizedId);
+  if (!task) {
+    error(`Task ${normalizedId} not found in TASKS/ directory`);
+    process.exit(1);
+  }
+  info(`Found task: ${task.title}`);
+  info(`Current status: ${task.status}`);
+  if (task.status !== "in-progress") {
+    error('Task is not in progress. Use "taskin start" first.');
+    process.exit(1);
+  }
+  const commitMessage = options.message || `WIP: task-${normalizedId} - ${task.title}`;
+  if (options.skipCommit) {
+    info("Would create commit with message:");
+    console.log(colors.highlight(`  "${commitMessage}"`));
+    console.log();
+    info("Use without --skip-commit to actually commit");
+  } else {
+    info("Creating commit...");
+    console.log(colors.secondary(`  Message: "${commitMessage}"`));
+    console.log();
+    success("Task paused successfully!");
+    info("Commit created (not pushed)");
+    console.log();
+    info("Next steps:");
+    console.log(colors.secondary("  1. Switch to another task"));
+    console.log(
+      colors.secondary("  2. Or continue later with the same branch")
+    );
+  }
+  console.log();
+}
+
+// src/commands/start.ts
+init_esm_shims();
+import path6 from "path";
+var startCommand = defineCommand({
+  name: "start <task-id>",
+  description: "\u{1F680} Start working on a task",
+  alias: "begin",
+  options: [
+    {
+      flags: "-f, --force",
+      description: "Force start even with uncommitted changes"
+    },
+    {
+      flags: "-b, --base <branch>",
+      description: "Base branch to create from (default: current)"
+    }
+  ],
+  handler: async (taskId, options) => {
+    await startTask(taskId, options);
+  }
+});
+async function startTask(taskId, _options) {
+  printHeader(`Starting Task ${taskId}`, "\u{1F680}");
+  const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
+  const tasksDir = path6.join(process.cwd(), "TASKS");
+  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const taskManager = new TaskManager(taskProvider);
+  const task = await taskProvider.findTask(normalizedId);
+  if (!task) {
+    error(`Task ${normalizedId} not found in TASKS/ directory`);
+    process.exit(1);
+  }
+  info(`Found task: ${task.title}`);
+  info(`Current status: ${task.status}`);
+  if (task.status === "in-progress") {
+    error("Task is already in progress");
+    process.exit(1);
+  }
+  if (task.status === "done") {
+    error("Task is already done");
+    process.exit(1);
+  }
+  info("Starting task...");
+  const updatedTask = await taskManager.startTask(task.id);
+  success(`Task ${updatedTask.id} started successfully!`);
+  success(`Status changed to: ${updatedTask.status}`);
+  console.log();
+  info("Next steps:");
+  console.log(
+    colors.secondary(
+      "  1. Create a branch: git checkout -b feat/task-" + normalizedId
+    )
+  );
+  console.log(colors.secondary("  2. Start coding! \u{1F4BB}"));
+  console.log(colors.secondary('  3. Use "taskin pause" to save progress'));
+  console.log();
+}
+
+// src/lib/help.ts
+init_esm_shims();
+function showCustomHelp() {
+  printHeader("Taskin - Task Management System", icons.rocket);
+  console.log(colors.info("\u{1F4CB} AVAILABLE COMMANDS"));
+  console.log(colors.highlight("\u2550".repeat(60)));
+  console.log();
+  const commands = [
+    {
+      name: colors.highlight("taskin init"),
+      alias: colors.secondary("Alias: setup"),
+      description: "Initialize Taskin in your project",
+      examples: ["taskin init", "taskin setup"],
+      icon: "\u{1F3AF}"
+    },
+    {
+      name: colors.highlight("taskin list") + colors.normal(" [filter]"),
+      alias: colors.secondary("Alias: ls"),
+      description: "List all tasks in the project",
+      examples: [
+        "taskin list",
+        "taskin list pending",
+        "taskin list --status in-progress",
+        "taskin list --type feat"
+      ],
+      icon: "\u{1F4CA}"
+    },
+    {
+      name: colors.highlight("taskin start") + colors.normal(" <task-id>"),
+      alias: colors.secondary("Alias: begin"),
+      description: "Start working on a task",
+      examples: [
+        "taskin start 001",
+        "taskin start task-001",
+        "taskin start 001 --force"
+      ],
+      icon: "\u{1F680}"
+    },
+    {
+      name: colors.highlight("taskin pause") + colors.normal(" <task-id>"),
+      alias: colors.secondary("Alias: stop"),
+      description: "Pause a task (commit without push)",
+      examples: ["taskin pause 001", 'taskin pause 001 -m "saving progress"'],
+      icon: "\u23F8\uFE0F"
+    },
+    {
+      name: colors.highlight("taskin finish") + colors.normal(" <task-id>"),
+      alias: colors.secondary("Alias: done"),
+      description: "Finish a task",
+      examples: ["taskin finish 001", "taskin done task-001"],
+      icon: "\u2705"
+    },
+    {
+      name: colors.highlight("taskin lint") + colors.normal(" [options]"),
+      alias: colors.secondary("Options: -p, --path <directory>"),
+      description: "Validate task markdown files",
+      examples: [
+        "taskin lint",
+        "taskin lint --path ./TASKS",
+        "taskin lint -p /path/to/tasks"
+      ],
+      icon: "\u{1F50D}"
+    }
+  ];
+  commands.forEach((cmd, index) => {
+    console.log(colors.warning(`${cmd.icon} ${cmd.name}`));
+    console.log(colors.normal(`   ${cmd.alias}`));
+    console.log(colors.info(`   ${cmd.description}`));
+    console.log();
+    console.log(colors.normal(`   ${colors.info("\u{1F4DD} Examples:")}`));
+    cmd.examples.forEach((example) => {
+      console.log(colors.secondary(`      ${example}`));
+    });
+    if (index < commands.length - 1) {
+      console.log();
+      console.log(colors.normal("   " + colors.secondary("\u2500".repeat(50))));
+      console.log();
+    }
+  });
+  console.log();
+  console.log(colors.highlight("\u2550".repeat(60)));
+  console.log();
+  console.log(colors.info("\u{1F4A1} QUICK TIPS"));
+  console.log(
+    colors.normal(
+      `${colors.warning("\u2022")} Use short IDs: ${colors.highlight("001")}, ${colors.highlight("task-001")}`
+    )
+  );
+  console.log(
+    colors.normal(
+      `${colors.warning("\u2022")} All commands support ${colors.highlight("--help")} for more options`
+    )
+  );
+  console.log(
+    colors.normal(
+      `${colors.warning("\u2022")} Use aliases for faster commands: ${colors.highlight("ls")}, ${colors.highlight("begin")}, ${colors.highlight("stop")}, ${colors.highlight("done")}`
+    )
+  );
+  console.log();
+  console.log(colors.info("\u{1F527} FOR MORE HELP"));
+  console.log(
+    colors.secondary("taskin ") + colors.highlight("<command>") + colors.secondary(" --help")
+  );
+  console.log();
+  return "";
+}
+
+// src/main.ts
+init_esm_shims();
+import { join as join4 } from "path";
+
+// src/taskin.ts
+init_esm_shims();
+var Taskin = class {
+  constructor(taskProvider, taskManager, linter) {
+    this.taskProvider = taskProvider;
+    this.taskManager = taskManager;
+    this.linter = linter;
+  }
+  async list(options) {
+    const tasks = await this.taskProvider.getAllTasks();
+    return tasks.map((taskFile) => {
+      const task = {
+        createdAt: taskFile.createdAt,
+        id: taskFile.id,
+        status: taskFile.status,
+        title: taskFile.title,
+        type: taskFile.type,
+        assignee: taskFile.userId
+        // Map userId to assignee
+      };
+      return task;
+    }).filter((task) => {
+      if (options?.status && task.status !== options.status) {
+        return false;
+      }
+      if (options?.type && task.type !== options.type) {
+        return false;
+      }
+      if (options?.assignee && task.assignee !== options.assignee) {
+        return false;
+      }
+      return true;
+    });
+  }
+  async start(taskId, options) {
+    const task = await this.taskProvider.findTask(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    await this.taskManager.startTask(taskId);
+    if (options?.force) {
+    }
+    if (options?.base) {
+    }
+  }
+  async pause(taskId, options) {
+    const task = await this.taskProvider.findTask(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    if (!options?.skipCommit) {
+      task.status = "pending";
+      await this.taskProvider.updateTask(task);
+    }
+    if (options?.message) {
+    }
+  }
+  async finish(taskId, _options) {
+    const task = await this.taskProvider.findTask(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    await this.taskManager.finishTask(taskId);
+  }
+  async lint(options) {
+    const lintPath = options?.path || "TASKS";
+    const fileResult = await this.linter.lintDirectory(lintPath);
+    return {
+      errors: fileResult.errors.map((e) => ({
+        taskId: e.file,
+        message: e.message,
+        severity: e.severity,
+        line: e.line
+      })),
+      warnings: fileResult.warnings.map((e) => ({
+        taskId: e.file,
+        message: e.message,
+        severity: e.severity,
+        line: e.line
+      })),
+      tasksChecked: fileResult.filesChecked,
+      valid: fileResult.valid
+    };
+  }
+};
+
+// src/main.ts
+function createTaskin(tasksDir) {
+  const resolvedTasksDir = tasksDir || join4(process.cwd(), "TASKS");
+  const taskProvider = new FileSystemTaskProvider(resolvedTasksDir);
+  const taskManager = new TaskManager(taskProvider);
+  const linter = new FileSystemTaskLinter();
+  return new Taskin(taskProvider, taskManager, linter);
+}
+function getTaskin() {
+  return createTaskin();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("taskin").description("\u{1F680} Task Management System").version("0.1.0").configureHelp({
+  formatHelp: () => showCustomHelp()
+});
 initCommand(program);
 listCommand(program);
 startCommand(program);
 pauseCommand(program);
 finishCommand(program);
 lintCommand(program);
-// Show custom help if no command provided
 if (process.argv.length <= 2) {
   showCustomHelp();
   process.exit(0);
 }
-// Parse arguments
 program.parse();
-export { createTaskin, getTaskin } from './main.js';
-export { Taskin } from './taskin.js';
-//# sourceMappingURL=index.js.map
+export {
+  Taskin,
+  createTaskin,
+  getTaskin
+};