taskin 1.0.3 → 1.0.4

package/README.md

@@ -98,6 +98,7 @@ Taskin is built as a modular ecosystem. Besides the CLI, you can use individual
 
 - `taskin init` - Initialize Taskin in your project with interactive setup
 - `taskin list` - List all tasks
+- `taskin new` - Create a new task (alias: `create`)
 - `taskin start <id>` - Start working on a task
 - `taskin pause <id>` - Pause work on a task
 - `taskin finish <id>` - Complete a task
@@ -154,7 +155,55 @@ Taskin uses a **plugin-based architecture** with dynamic provider loading:
 
 📚 See [ARCHITECTURE.md](./ARCHITECTURE.md) for detailed technical documentation.
 
-## 📖 Examples
+## 📝 Creating Tasks
+
+Use the `taskin new` command to create new task files:
+
+### Interactive Mode (Recommended)
+
+Simply run without arguments for a guided experience:
+
+```bash
+taskin new
+```
+
+You'll be prompted to select:
+
+- Task type (feat, fix, refactor, docs, test, chore)
+- Title
+- Description (optional)
+- Assignee (optional)
+
+### Command-line Mode
+
+Or provide all options directly:
+
+```bash
+# Create a new feature task
+taskin new -t feat -T "Add user authentication" -d "Implement JWT-based auth" -u "John Doe"
+
+# Create a bug fix task
+taskin new --type fix --title "Fix login error" --user "Developer"
+
+# Using the 'create' alias
+taskin create -t docs -T "Update README"
+```
+
+**Options:**
+
+- `-t, --type <type>` - Task type: feat, fix, refactor, docs, test, chore
+- `-T, --title <title>` - Task title (required in command-line mode)
+- `-d, --description <description>` - Task description
+- `-u, --user <user>` - Assigned user
+
+The command will:
+
+1. Auto-generate a task number (e.g., 05)
+2. Create a markdown file in `TASKS/` directory
+3. Use a slug from the title for the filename
+4. Pre-populate with a standard template
+
+## �📖 Examples
 
 See [EXAMPLES.md](./EXAMPLES.md) for detailed usage examples and workflows.
 

package/dist/index.js

@@ -13,9 +13,13 @@ var __esm = (fn, res) => function __init() {
 // ../../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 getFilename, getDirname, __dirname;
 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";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
   }
 });
 
@@ -26,54 +30,52 @@ import { Command } from "commander";
 // src/commands/finish.ts
 init_esm_shims();
 
-// ../fs-task-provider/src/index.ts
+// ../fs-task-provider/dist/index.js
 init_esm_shims();
 
-// ../fs-task-provider/src/fs-task-provider.ts
+// ../fs-task-provider/dist/fs-task-provider.js
 init_esm_shims();
 import { promises as fs } from "fs";
 import path2 from "path";
 var FileSystemTaskProvider = class {
+  tasksDirectory;
   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")
-    );
+    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 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: "unknown",
-      status: "pending",
-      type: "feat",
+      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()
     };
     return task;
   }
   async updateTask(task) {
     const currentContent = await fs.readFile(task.filePath, "utf-8");
-    const updatedContent = currentContent.replace(
-      /^Status:\s*.+$/im,
-      `Status: ${task.status}`
-    );
+    const updatedContent = currentContent.replace(/^Status:\s*.+$/im, `Status: ${task.status}`);
     await fs.writeFile(task.filePath, updatedContent, "utf-8");
   }
   async getAllTasks() {
     const files = await fs.readdir(this.tasksDirectory);
-    const taskFiles = files.filter(
-      (file) => file.startsWith("task-") && file.endsWith(".md")
-    );
+    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);
@@ -102,12 +104,13 @@ var FileSystemTaskProvider = class {
   }
 };
 
-// ../task-manager/src/index.ts
+// ../task-manager/dist/index.js
 init_esm_shims();
 
-// ../task-manager/src/task-manager.ts
+// ../task-manager/dist/task-manager.js
 init_esm_shims();
 var TaskManager = class {
+  taskProvider;
   constructor(taskProvider) {
     this.taskProvider = taskProvider;
   }
@@ -137,14 +140,14 @@ var TaskManager = class {
   }
 };
 
-// ../task-manager/src/task-manager.mock.ts
+// ../task-manager/dist/task-manager.mock.js
 init_esm_shims();
 
-// ../task-manager/src/task-manager.types.ts
+// ../task-manager/dist/task-manager.types.js
 init_esm_shims();
 
 // src/commands/finish.ts
-import path3 from "path";
+import path5 from "path";
 
 // src/lib/colors.ts
 init_esm_shims();
@@ -184,6 +187,51 @@ function info(message) {
   console.log(colors.info(`\u2139 ${message}`));
 }
 
+// src/lib/project-check.ts
+init_esm_shims();
+import { existsSync } from "fs";
+import path3 from "path";
+function isTaskinProject(cwd = process.cwd()) {
+  return existsSync(path3.join(cwd, ".taskin.json"));
+}
+function requireTaskinProject(cwd = process.cwd()) {
+  if (!isTaskinProject(cwd)) {
+    error(
+      'This directory is not initialized as a taskin project. Run "taskin init" first.'
+    );
+    process.exit(1);
+  }
+}
+
+// src/lib/sound-player.ts
+init_esm_shims();
+import { existsSync as existsSync2 } from "fs";
+import path4 from "path";
+import player from "play-sound";
+var soundPlayer = player({});
+function playSound(soundName) {
+  try {
+    const possiblePaths = [
+      // In development (from src)
+      path4.join(process.cwd(), "packages", "cli", "sounds", `${soundName}.mp3`),
+      // In production (relative to dist)
+      path4.join(__dirname, "..", "sounds", `${soundName}.mp3`),
+      // Custom sound in project root
+      path4.join(process.cwd(), ".taskin", `${soundName}.mp3`)
+    ];
+    const soundPath = possiblePaths.find((p) => existsSync2(p));
+    if (!soundPath) {
+      return;
+    }
+    soundPlayer.play(soundPath, (err) => {
+      if (err) {
+        return;
+      }
+    });
+  } catch {
+  }
+}
+
 // src/commands/define-command/index.ts
 init_esm_shims();
 
@@ -223,6 +271,10 @@ var finishCommand = defineCommand({
     {
       flags: "-s, --skip-update",
       description: "Skip updating task status"
+    },
+    {
+      flags: "--no-sound",
+      description: "Disable finish sound"
     }
   ],
   handler: async (taskId, options) => {
@@ -230,9 +282,10 @@ var finishCommand = defineCommand({
   }
 });
 async function finishTask(taskId, options) {
+  requireTaskinProject();
   printHeader(`Finishing Task ${taskId}`, "\u2705");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path3.join(process.cwd(), "TASKS");
+  const tasksDir = path5.join(process.cwd(), "TASKS");
   const taskProvider = new FileSystemTaskProvider(tasksDir);
   const taskManager = new TaskManager(taskProvider);
   const task = await taskProvider.findTask(normalizedId);
@@ -269,11 +322,14 @@ async function finishTask(taskId, options) {
   console.log();
   success("Great work! \u{1F680}");
   console.log();
+  if (options.sound !== false) {
+    playSound("finish");
+  }
 }
 
 // src/commands/init.ts
 init_esm_shims();
-import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { existsSync as existsSync4, mkdirSync, writeFileSync } from "fs";
 import inquirer from "inquirer";
 import { join } from "path";
 
@@ -283,12 +339,12 @@ init_esm_shims();
 // src/lib/provider-installer/provider-installer.ts
 init_esm_shims();
 import { execSync } from "child_process";
-import { existsSync } from "fs";
+import { existsSync as existsSync3 } from "fs";
 function detectPackageManager() {
-  if (existsSync("pnpm-lock.yaml")) {
+  if (existsSync3("pnpm-lock.yaml")) {
     return "pnpm";
   }
-  if (existsSync("yarn.lock")) {
+  if (existsSync3("yarn.lock")) {
     return "yarn";
   }
   return "npm";
@@ -483,6 +539,10 @@ var initCommand = defineCommand({
     {
       flags: "-f, --force",
       description: "Force initialization (overwrite existing configuration)"
+    },
+    {
+      flags: "-p, --provider <provider>",
+      description: "Provider to use (fs, redmine, jira, github) - skips interactive prompt"
     }
   ],
   handler: async (options) => {
@@ -493,7 +553,7 @@ async function initializeTaskin(options) {
   printHeader("Initializing Taskin", "\u{1F3AF}");
   const cwd = process.cwd();
   const configFile = join(cwd, ".taskin.json");
-  if (existsSync2(configFile) && !options.force) {
+  if (existsSync4(configFile) && !options.force) {
     error("Taskin is already initialized in this project");
     info("Use --force to reinitialize");
     process.exit(1);
@@ -509,15 +569,25 @@ async function initializeTaskin(options) {
       disabled: p.status === "coming-soon" ? "Not yet implemented" : false
     };
   });
-  const { providerId } = await inquirer.prompt([
-    {
-      type: "list",
-      name: "providerId",
-      message: "Select a task provider:",
-      choices,
-      default: "fs"
-    }
-  ]);
+  let providerId;
+  if (options.provider) {
+    providerId = options.provider;
+    info(`Using provider from command line: ${colors.highlight(providerId)}`);
+  } else if (process.env.CI === "true") {
+    providerId = "fs";
+    info("CI environment detected, using default provider: fs");
+  } else {
+    const response = await inquirer.prompt([
+      {
+        type: "list",
+        name: "providerId",
+        message: "Select a task provider:",
+        choices,
+        default: "fs"
+      }
+    ]);
+    providerId = response.providerId;
+  }
   const selectedProvider = getProviderById(providerId);
   if (!selectedProvider) {
     error(`Provider "${providerId}" not found`);
@@ -542,7 +612,7 @@ async function initializeTaskin(options) {
   writeFileSync(configFile, JSON.stringify(config, null, 2), "utf-8");
   success(`\u2713 Created ${colors.highlight(".taskin.json")}`);
   const gitignorePath = join(cwd, ".gitignore");
-  if (existsSync2(gitignorePath)) {
+  if (existsSync4(gitignorePath)) {
     const gitignoreContent = __require("fs").readFileSync(gitignorePath, "utf-8");
     if (!gitignoreContent.includes(".taskin.json")) {
       info("Adding .taskin.json to .gitignore...");
@@ -564,7 +634,7 @@ async function initializeTaskin(options) {
   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}`
+      selectedProvider.id === "fs" ? "  2. Create a new task: taskin new (interactive mode)" : `  2. Tasks will be synced with ${selectedProvider.name}`
     )
   );
   console.log(colors.secondary("  3. Start working: taskin start <task-id>"));
@@ -598,15 +668,16 @@ async function setupProviderConfig(provider, cwd) {
 }
 async function setupFileSystemProvider(cwd) {
   const tasksDir = join(cwd, "TASKS");
-  if (!existsSync2(tasksDir)) {
+  if (!existsSync4(tasksDir)) {
     info(`Creating TASKS directory...`);
     mkdirSync(tasksDir, { recursive: true });
     success(`\u2713 Created ${colors.highlight("TASKS/")} directory`);
   } else {
     info(`${colors.highlight("TASKS/")} directory already exists`);
+    success("\u2713 Directory is ready to use");
   }
   const sampleTaskFile = join(tasksDir, "task-001-setup-project.md");
-  if (!existsSync2(sampleTaskFile)) {
+  if (!existsSync4(sampleTaskFile)) {
     info("Creating sample task...");
     const sampleTask = `# Task 001 \u2014 Setup Project
 
@@ -942,7 +1013,7 @@ async function executeLint(options) {
 
 // src/commands/list.ts
 init_esm_shims();
-import path4 from "path";
+import path6 from "path";
 var listCommand = defineCommand({
   name: "list [filter]",
   description: "\u{1F4CA} List all tasks in the project",
@@ -966,8 +1037,9 @@ var listCommand = defineCommand({
   }
 });
 async function listTasks(filter, options) {
+  requireTaskinProject();
   printHeader("Task List", "\u{1F4CA}");
-  const tasksDir = path4.join(process.cwd(), "TASKS");
+  const tasksDir = path6.join(process.cwd(), "TASKS");
   const taskProvider = new FileSystemTaskProvider(tasksDir);
   const tasks = await taskProvider.getAllTasks();
   if (tasks.length === 0) {
@@ -1057,9 +1129,170 @@ function getTypeColor(type) {
   }
 }
 
+// src/commands/new.ts
+init_esm_shims();
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import inquirer2 from "inquirer";
+import path7 from "path";
+var createCommand = defineCommand({
+  name: "new",
+  description: "\u2795 Create a new task",
+  alias: "create",
+  options: [
+    {
+      flags: "-t, --type <type>",
+      description: "Task type (feat, fix, refactor, docs, test, chore)"
+    },
+    {
+      flags: "-T, --title <title>",
+      description: "Task title"
+    },
+    {
+      flags: "-d, --description <description>",
+      description: "Task description"
+    },
+    {
+      flags: "-u, --user <user>",
+      description: "Assignee user"
+    }
+  ],
+  handler: async (options) => {
+    await createTask(options);
+  }
+});
+async function createTask(options) {
+  requireTaskinProject();
+  printHeader("Create New Task", "\u2795");
+  const validTypes = ["feat", "fix", "refactor", "docs", "test", "chore"];
+  if (!options.type && !options.title) {
+    info("Interactive mode - Answer the questions below:");
+    console.log();
+    const answers = await inquirer2.prompt([
+      {
+        type: "list",
+        name: "type",
+        message: "Select task type:",
+        choices: [
+          { name: "\u2728 feat - New feature", value: "feat" },
+          { name: "\u{1F41B} fix - Bug fix", value: "fix" },
+          { name: "\u267B\uFE0F  refactor - Code refactoring", value: "refactor" },
+          { name: "\u{1F4DD} docs - Documentation", value: "docs" },
+          { name: "\u2705 test - Tests", value: "test" },
+          { name: "\u{1F527} chore - Maintenance", value: "chore" }
+        ],
+        default: "feat"
+      },
+      {
+        type: "input",
+        name: "title",
+        message: "Task title:",
+        validate: (input) => {
+          if (input.trim().length === 0) {
+            return "Title is required";
+          }
+          return true;
+        }
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Task description (optional):"
+      },
+      {
+        type: "input",
+        name: "user",
+        message: "Assignee (optional):",
+        default: "A definir"
+      }
+    ]);
+    options.type = answers.type;
+    options.title = answers.title;
+    options.description = answers.description;
+    options.user = answers.user;
+    console.log();
+  }
+  if (!options.type) {
+    error("Task type is required. Use --type <type>");
+    return;
+  }
+  if (!options.title) {
+    error("Task title is required. Use --title <title>");
+    return;
+  }
+  if (!validTypes.includes(options.type)) {
+    error(
+      `Invalid task type: ${options.type}. Must be one of: ${validTypes.join(", ")}`
+    );
+    return;
+  }
+  const tasksDir = path7.join(process.cwd(), "TASKS");
+  if (!existsSync5(tasksDir)) {
+    mkdirSync2(tasksDir, { recursive: true });
+  }
+  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const allTasks = await taskProvider.getAllTasks();
+  const taskNumbers = allTasks.map((task) => {
+    const match = task.id.match(/^(\d+)$/);
+    return match ? parseInt(match[1], 10) : 0;
+  }).filter((num) => !isNaN(num));
+  const nextNumber = taskNumbers.length > 0 ? Math.max(...taskNumbers) + 1 : 1;
+  const taskId = String(nextNumber).padStart(3, "0");
+  const titleSlug = options.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  const fileName = `task-${taskId}-${titleSlug}.md`;
+  const filePath = path7.join(tasksDir, fileName);
+  if (existsSync5(filePath)) {
+    error(`Task file already exists: ${fileName}`);
+    return;
+  }
+  const taskContent = generateTaskMarkdown({
+    id: taskId,
+    type: options.type,
+    title: options.title,
+    description: options.description || "",
+    user: options.user || "A definir"
+  });
+  writeFileSync2(filePath, taskContent, "utf-8");
+  console.log();
+  success(`Task ${taskId} created successfully!`);
+  console.log(colors.secondary(`\u{1F4C4} File: ${fileName}`));
+  console.log(colors.secondary(`\u{1F4C1} Path: ${filePath}`));
+  console.log();
+  console.log(colors.info("Next steps:"));
+  console.log(colors.normal(`  1. Edit the task file to add more details`));
+  console.log(
+    colors.normal(
+      `  2. Run ${colors.highlight("taskin start " + taskId)} to begin working on it`
+    )
+  );
+  console.log();
+}
+function generateTaskMarkdown(data) {
+  return `# Task ${data.id} \u2014 ${data.title}
+
+Status: pending
+Type: ${data.type}
+Assignee: ${data.user}
+
+## Description
+
+${data.description || "Add task description here..."}
+
+## Tasks
+
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+
+## Notes
+
+Add any relevant notes or links here.
+`;
+}
+
 // src/commands/pause.ts
 init_esm_shims();
-import path5 from "path";
+import { execSync as execSync2 } from "child_process";
+import path8 from "path";
 var pauseCommand = defineCommand({
   name: "pause <task-id>",
   description: "\u23F8\uFE0F  Pause work on a task",
@@ -1072,6 +1305,10 @@ var pauseCommand = defineCommand({
     {
       flags: "-s, --skip-commit",
       description: "Skip commit (just show what would be done)"
+    },
+    {
+      flags: "--no-sound",
+      description: "Disable pause sound"
     }
   ],
   handler: async (taskId, options) => {
@@ -1079,9 +1316,10 @@ var pauseCommand = defineCommand({
   }
 });
 async function pauseTask(taskId, options) {
+  requireTaskinProject();
   printHeader(`Pausing Task ${taskId}`, "\u23F8\uFE0F");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path5.join(process.cwd(), "TASKS");
+  const tasksDir = path8.join(process.cwd(), "TASKS");
   const taskProvider = new FileSystemTaskProvider(tasksDir);
   const task = await taskProvider.findTask(normalizedId);
   if (!task) {
@@ -1104,21 +1342,35 @@ async function pauseTask(taskId, options) {
     info("Creating commit...");
     console.log(colors.secondary(`  Message: "${commitMessage}"`));
     console.log();
+    try {
+      execSync2("git add -A", { cwd: process.cwd(), stdio: "ignore" });
+      execSync2(`git commit -m "${commitMessage}"`, {
+        cwd: process.cwd(),
+        stdio: "ignore"
+      });
+    } catch {
+    }
+    const updatedTask = { ...task, status: "pending" };
+    await taskProvider.updateTask(updatedTask);
     success("Task paused successfully!");
     info("Commit created (not pushed)");
+    info("Status updated to pending");
     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")
     );
+    if (options.sound !== false) {
+      playSound("stop");
+    }
   }
   console.log();
 }
 
 // src/commands/start.ts
 init_esm_shims();
-import path6 from "path";
+import path9 from "path";
 var startCommand = defineCommand({
   name: "start <task-id>",
   description: "\u{1F680} Start working on a task",
@@ -1131,6 +1383,10 @@ var startCommand = defineCommand({
     {
       flags: "-b, --base <branch>",
       description: "Base branch to create from (default: current)"
+    },
+    {
+      flags: "--no-sound",
+      description: "Disable start sound"
     }
   ],
   handler: async (taskId, options) => {
@@ -1138,9 +1394,10 @@ var startCommand = defineCommand({
   }
 });
 async function startTask(taskId, _options) {
+  requireTaskinProject();
   printHeader(`Starting Task ${taskId}`, "\u{1F680}");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path6.join(process.cwd(), "TASKS");
+  const tasksDir = path9.join(process.cwd(), "TASKS");
   const taskProvider = new FileSystemTaskProvider(tasksDir);
   const taskManager = new TaskManager(taskProvider);
   const task = await taskProvider.findTask(normalizedId);
@@ -1172,6 +1429,9 @@ async function startTask(taskId, _options) {
   console.log(colors.secondary("  2. Start coding! \u{1F4BB}"));
   console.log(colors.secondary('  3. Use "taskin pause" to save progress'));
   console.log();
+  if (_options.sound !== false) {
+    playSound("start");
+  }
 }
 
 // src/lib/help.ts
@@ -1201,6 +1461,17 @@ function showCustomHelp() {
       ],
       icon: "\u{1F4CA}"
     },
+    {
+      name: colors.highlight("taskin new"),
+      alias: colors.secondary("Alias: create"),
+      description: "Create a new task",
+      examples: [
+        'taskin new -t feat -T "Add login" -d "Implement user authentication"',
+        'taskin new --type fix --title "Fix bug" --user "John"',
+        'taskin create -t docs -T "Update README"'
+      ],
+      icon: "\u{1F4DD}"
+    },
     {
       name: colors.highlight("taskin start") + colors.normal(" <task-id>"),
       alias: colors.secondary("Alias: begin"),
@@ -1407,6 +1678,7 @@ program.name("taskin").description("\u{1F680} Task Management System").version(g
 });
 initCommand(program);
 listCommand(program);
+createCommand(program);
 startCommand(program);
 pauseCommand(program);
 finishCommand(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskin",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Task management system integrated with Git workflows",
   "motivation": "Provide a CLI tool for task management integrated with Git workflows",
   "solve": "Simplifies task tracking and management directly from the command line",
@@ -57,6 +57,7 @@
   },
   "files": [
     "dist",
+    "sounds",
     "README.md",
     "LICENSE"
   ],
@@ -75,10 +76,16 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@opentask/taskin-fs-provider": "workspace:*",
+    "@opentask/taskin-task-manager": "workspace:*",
+    "@opentask/taskin-types": "workspace:*",
+    "@opentask/taskin-utils": "workspace:*",
     "@types/inquirer": "^9.0.9",
+    "@types/play-sound": "^1.1.2",
     "chalk": "^5.6.2",
     "commander": "^12.1.0",
     "inquirer": "^12.11.0",
+    "play-sound": "^1.1.6",
     "zod": "^3.25.76"
   },
   "devDependencies": {

package/sounds/README.md

@@ -0,0 +1,82 @@
+# Audio Sounds for Taskin
+
+This directory contains optional audio files that can be played during CLI operations.
+
+## Included Sounds
+
+### `start.mp3`
+
+Played when you start a task with `taskin start` command.
+Sound effect: CS:GO "Go Go Go!"
+
+### `finish.mp3`
+
+Played when you finish a task with `taskin finish` or `taskin done` command.
+Sound effect: CS:GO "Bomb has been planted"
+
+### `stop.mp3` (TODO)
+
+Played when you pause a task with `taskin pause` or `taskin stop` command.
+**Note:** This file needs to be added. Sound effect: (to be defined)
+
+## How to Add Custom Sounds
+
+1. **Built-in sounds**: Place MP3 files in this directory (`packages/cli/sounds/`)
+2. **Project-specific sounds**: Create a `.taskin/` directory in your project root and add MP3 files there
+
+## Adding Your Own Sounds
+
+To add custom sounds:
+
+1. Create a `.taskin/` directory in your project:
+
+   ```bash
+   mkdir .taskin
+   ```
+
+2. Add your MP3 files (you can customize any of these):
+
+   ```bash
+   cp /path/to/your/start-sound.mp3 .taskin/start.mp3
+   cp /path/to/your/finish-sound.mp3 .taskin/finish.mp3
+   cp /path/to/your/pause-sound.mp3 .taskin/stop.mp3
+   ```
+
+3. The sounds will play automatically on the respective commands!
+
+## Disabling Sound
+
+To disable sounds, use the `--no-sound` flag:
+
+```bash
+taskin start 001 --no-sound
+taskin finish 001 --no-sound
+taskin pause 001 --no-sound
+```
+
+## Requirements
+
+The sound player uses system audio utilities. Make sure you have one of these installed:
+
+- **Linux**: `mpg123`, `ffplay`, or `mplayer`
+- **macOS**: `afplay` (built-in)
+- **Windows**: Built-in Windows Media Player
+
+### Installing audio players on Linux:
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install mpg123
+
+# Fedora
+sudo dnf install mpg123
+
+# Arch
+sudo pacman -S mpg123
+```
+
+## Notes
+
+- Sounds are played asynchronously and won't block CLI operations
+- If no sound file is found, the command executes silently
+- Sound playback errors are silently ignored

package/dist/index.d.ts

@@ -1,383 +0,0 @@
-#!/usr/bin/env node
-import { z } from 'zod';
-
-/**
- * Task identifier schema.
- * Represents a unique identifier for a task (UUID format).
- *
- * @public
- */
-declare const TaskIdSchema: z.ZodBranded<z.ZodString, "TaskId">;
-/**
- * Runtime validator for task type values.
- * Use this to validate user input or external data.
- *
- * @public
- */
-declare const TaskTypeSchema: z.ZodEnum<["feat", "fix", "refactor", "docs", "test", "chore"]>;
-/**
- * Runtime validator for task objects.
- * Use this to parse and validate task data from external sources (API, database, forms).
- *
- * @public
- * @example
- * ```ts
- * // Parse and validate task data
- * const task = TaskSchema.parse(userInput);
- *
- * // Safe parse with error handling
- * const result = TaskSchema.safeParse(untrustedData);
- * if (result.success) {
- *   console.log(result.data);
- * }
- * ```
- */
-declare const TaskSchema: z.ZodObject<{
-    createdAt: z.ZodString;
-    id: z.ZodBranded<z.ZodString, "TaskId">;
-    status: z.ZodEnum<["pending", "in-progress", "done", "blocked"]>;
-    title: z.ZodString;
-    type: z.ZodEnum<["feat", "fix", "refactor", "docs", "test", "chore"]>;
-    assignee: z.ZodOptional<z.ZodString>;
-    completed: z.ZodOptional<z.ZodBoolean>;
-    description: z.ZodOptional<z.ZodString>;
-    userId: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    createdAt: string;
-    id: string & z.BRAND<"TaskId">;
-    status: "pending" | "in-progress" | "done" | "blocked";
-    title: string;
-    type: "feat" | "fix" | "refactor" | "docs" | "test" | "chore";
-    assignee?: string | undefined;
-    completed?: boolean | undefined;
-    description?: string | undefined;
-    userId?: string | undefined;
-}, {
-    createdAt: string;
-    id: string;
-    status: "pending" | "in-progress" | "done" | "blocked";
-    title: string;
-    type: "feat" | "fix" | "refactor" | "docs" | "test" | "chore";
-    assignee?: string | undefined;
-    completed?: boolean | undefined;
-    description?: string | undefined;
-    userId?: string | undefined;
-}>;
-/**
- * Runtime validator for user objects.
- * Use this to parse and validate user data from external sources.
- *
- * @public
- */
-declare const UserSchema: z.ZodObject<{
-    email: z.ZodString;
-    id: z.ZodString;
-    name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    email: string;
-    name: string;
-}, {
-    id: string;
-    email: string;
-    name: string;
-}>;
-
-/**
- * Taskin Core Interface
- * Main interface for task management operations
- */
-
-interface ListTasksOptions {
-    assignee?: string;
-    status?: string;
-    type?: string;
-}
-interface StartTaskOptions {
-    base?: string;
-    force?: boolean;
-}
-interface PauseTaskOptions {
-    message?: string;
-    skipCommit?: boolean;
-}
-interface FinishTaskOptions {
-    push?: boolean;
-    skipUpdate?: boolean;
-}
-interface LintTasksOptions {
-    path?: string;
-}
-/**
- * Validation issue found during task linting
- * Provider-agnostic - works with any task storage backend
- */
-interface TaskValidationIssue {
-    message: string;
-    severity: 'error' | 'warning';
-    taskId: string;
-    line?: number;
-}
-/**
- * Task metadata extracted from task source
- */
-interface TaskMetadata {
-    assignee?: string;
-    status?: string;
-    type?: string;
-}
-/**
- * Result of task validation/linting operation
- */
-interface LintResult {
-    errors: TaskValidationIssue[];
-    tasksChecked: number;
-    valid: boolean;
-    warnings: TaskValidationIssue[];
-}
-/**
- * ITaskin - Core interface for task management system
- */
-interface ITaskin {
-    /**
-     * Finish a task
-     */
-    finish(taskId: TaskId, options?: FinishTaskOptions): Promise<void>;
-    /**
-     * Lint/validate tasks from the configured provider
-     */
-    lint(options?: LintTasksOptions): Promise<LintResult>;
-    /**
-     * List all tasks with optional filters
-     */
-    list(options?: ListTasksOptions): Promise<Task[]>;
-    /**
-     * Pause work on a task
-     */
-    pause(taskId: TaskId, options?: PauseTaskOptions): Promise<void>;
-    /**
-     * Start working on a task
-     */
-    start(taskId: TaskId, options?: StartTaskOptions): Promise<void>;
-}
-/**
- * Unique identifier for a task (UUID branded type).
- * Use this type for type-safe task ID handling across the system.
- *
- * @public
- * @example
- * ```ts
- * function getTask(id: TaskId): Task { ... }
- * const taskId: TaskId = '550e8400-e29b-41d4-a716-446655440000' as TaskId;
- * ```
- */
-type TaskId = z.infer<typeof TaskIdSchema>;
-/**
- * Type of task based on the kind of work being performed.
- * Follows conventional commit types for consistency across the codebase.
- *
- * @public
- */
-type TaskType = z.infer<typeof TaskTypeSchema>;
-/**
- * Represents a task in the Taskin system.
- * Contains all core information needed to track and manage work items.
- *
- * @public
- */
-type Task = z.infer<typeof TaskSchema>;
-/**
- * Represents a user in the Taskin system.
- * Contains basic user identification and contact information.
- *
- * @public
- */
-type User = z.infer<typeof UserSchema>;
-
-/**
- * A task with additional file system metadata.
- * Extends the base Task type with content and path information.
- * @public
- */
-type TaskFile = Task & {
-    /** The raw markdown content of the task file */
-    content: string;
-    /** Absolute or relative path to the task file */
-    filePath: string;
-    /** The type of work this task represents */
-    type: TaskType;
-    /** Optional user assigned to this task */
-    assignee?: User;
-};
-/**
- * Interface for task storage providers.
- * Implementations handle reading and writing tasks from different sources
- * (e.g., file system, database, API).
- * @public
- */
-interface ITaskProvider {
-    /**
-     * Find a specific task by its ID.
-     * @param taskId - The unique identifier of the task
-     * @returns The task if found, undefined otherwise
-     */
-    findTask(taskId: string): Promise<TaskFile | undefined>;
-    /**
-     * Retrieve all tasks from the provider.
-     * @returns Array of all tasks
-     */
-    getAllTasks(): Promise<TaskFile[]>;
-    /**
-     * Update an existing task.
-     * @param task - The task with updated information
-     */
-    updateTask(task: TaskFile): Promise<void>;
-}
-/**
- * Interface for task management operations.
- * Provides high-level methods for managing task workflow and state transitions.
- * @public
- */
-interface ITaskManager {
-    /**
-     * Mark a task as finished.
-     * Transitions the task to 'done' status.
-     * @param taskId - The unique identifier of the task
-     * @returns The updated task
-     * @throws Error if task is not found
-     */
-    finishTask(taskId: string): Promise<TaskFile>;
-    /**
-     * Start working on a task.
-     * Transitions the task to 'in-progress' status.
-     * @param taskId - The unique identifier of the task
-     * @returns The updated task
-     * @throws Error if task is not found, already in progress, or already done
-     */
-    startTask(taskId: string): Promise<TaskFile>;
-}
-
-declare class TaskManager implements ITaskManager {
-    private taskProvider;
-    constructor(taskProvider: ITaskProvider);
-    startTask(taskId: string): Promise<TaskFile>;
-    finishTask(taskId: string): Promise<TaskFile>;
-}
-
-declare class FileSystemTaskProvider implements ITaskProvider {
-    private tasksDirectory;
-    constructor(tasksDirectory: string);
-    findTask(taskId: string): Promise<TaskFile | undefined>;
-    updateTask(task: TaskFile): Promise<void>;
-    getAllTasks(): Promise<TaskFile[]>;
-}
-
-/**
- * FileSystem task linter types
- * Re-exports from @opentask/taskin-types + FileSystem-specific extensions
- */
-
-/**
- * FileSystem-specific validation error
- * Extends TaskValidationIssue with file-specific information
- */
-interface FileValidationError extends Omit<TaskValidationIssue, 'taskId'> {
-    file: string;
-}
-/**
- * FileSystem-specific lint result
- * Contains file-based validation results
- */
-interface FileLintResult {
-    errors: FileValidationError[];
-    filesChecked: number;
-    valid: boolean;
-    warnings: FileValidationError[];
-}
-/**
- * FileSystem-specific task linter interface
- * Defines validation operations for file-based task providers
- */
-interface IFileSystemTaskLinter {
-    /**
-     * Lint all task files in a directory
-     * @param tasksDir - Directory containing task markdown files
-     * @returns Validation results for all files
-     */
-    lintDirectory(tasksDir: string): Promise<FileLintResult>;
-    /**
-     * Lint a single task file
-     * @param filePath - Path to the task markdown file
-     * @returns Array of validation errors found in the file
-     */
-    lintFile(filePath: string): Promise<FileValidationError[]>;
-    /**
-     * Validate task metadata
-     * @param metadata - Task metadata to validate
-     * @param fileName - Name of the file being validated
-     * @returns Array of validation errors
-     */
-    validateMetadata(metadata: Record<string, unknown>, fileName: string): FileValidationError[];
-}
-
-/**
- * FileSystem-specific task linter implementation
- * Validates task markdown files in the local filesystem
- */
-declare class FileSystemTaskLinter implements IFileSystemTaskLinter {
-    private errors;
-    private addError;
-    /**
-     * Validate task file name format (FileSystem-specific)
-     */
-    validateFileName(fileName: string): FileValidationError | null;
-    private extractMetadata;
-    /**
-     * Validate task metadata (FileSystem-specific)
-     */
-    validateMetadata(metadata: TaskMetadata, filePath: string): FileValidationError[];
-    private validateContent;
-    /**
-     * Lint a single task file (FileSystem-specific)
-     */
-    lintFile(filePath: string): Promise<FileValidationError[]>;
-    /**
-     * Lint all task files in the specified directory (FileSystem-specific)
-     */
-    lintDirectory(tasksDir: string): Promise<FileLintResult>;
-    static printResults(result: FileLintResult): void;
-}
-
-/**
- * Taskin - Concrete implementation of ITaskin
- * Main class that implements task management with dependency injection
- */
-
-declare class Taskin implements ITaskin {
-    private readonly taskProvider;
-    private readonly taskManager;
-    private readonly linter;
-    constructor(taskProvider: FileSystemTaskProvider, taskManager: TaskManager, linter: FileSystemTaskLinter);
-    list(options?: ListTasksOptions): Promise<Task[]>;
-    start(taskId: TaskId, options?: StartTaskOptions): Promise<void>;
-    pause(taskId: TaskId, options?: PauseTaskOptions): Promise<void>;
-    finish(taskId: TaskId, _options?: FinishTaskOptions): Promise<void>;
-    lint(options?: LintTasksOptions): Promise<LintResult>;
-}
-
-/**
- * Main entry point for Taskin CLI
- * Handles dependency injection and initialization
- */
-
-/**
- * Factory function to create a configured Taskin instance
- */
-declare function createTaskin(tasksDir?: string): Taskin;
-/**
- * Get the default Taskin instance
- * Uses current working directory TASKS folder
- */
-declare function getTaskin(): Taskin;
-
-export { type ITaskin, Taskin, createTaskin, getTaskin };