taskin 1.0.13 → 2.0.1

package/dist/index.js

@@ -51,7 +51,7 @@ var init_esm_shims = __esm({
   }
 });
 
-// ../fs-task-provider/dist/i18n.js
+// ../file-system-task-provider/dist/i18n.js
 function getI18n(locale = "en-US") {
   return i18nConfig[locale];
 }
@@ -63,7 +63,7 @@ function detectLocale(content) {
 }
 var i18nConfig;
 var init_i18n = __esm({
-  "../fs-task-provider/dist/i18n.js"() {
+  "../file-system-task-provider/dist/i18n.js"() {
     "use strict";
     init_esm_shims();
     i18nConfig = {
@@ -93,7 +93,7 @@ var init_i18n = __esm({
   }
 });
 
-// ../fs-task-provider/dist/task-validator.js
+// ../file-system-task-provider/dist/task-validator.js
 var task_validator_exports = {};
 __export(task_validator_exports, {
   createLintResult: () => createLintResult,
@@ -121,13 +121,18 @@ async function fixTaskFile(filePath) {
     const hasSectionStatus = statusPattern.test(content);
     const hasSectionType = typePattern.test(content);
     const hasSectionAssignee = assigneePattern.test(content);
-    const inlineStatusPattern = /^(Status|Tipo):\s*(.+?)(\s*)$/im;
-    const inlineTypePattern = /^(Type|Tipo):\s*(.+?)(\s*)$/im;
-    const inlineAssigneePattern = /^(Assignee|Responsável):\s*(.+?)(\s*)$/im;
-    const hasInlineStatus = inlineStatusPattern.test(content);
-    const hasInlineType = inlineTypePattern.test(content);
-    const hasInlineAssignee = inlineAssigneePattern.test(content);
-    const needsSpaceFix = hasInlineStatus && !/^(?:Status|Tipo):.+  $/im.test(content) || hasInlineType && !/^(?:Type|Tipo):.+  $/im.test(content) || hasInlineAssignee && !/^(?:Assignee|Responsável):.+  $/im.test(content);
+    const inlineStatusPattern = /^(Status|Tipo):\s*/i;
+    const inlineTypePattern = /^(Type|Tipo):\s*/i;
+    const inlineAssigneePattern = /^(Assignee|Responsável):\s*/i;
+    const lines = content.split(/\r?\n/);
+    const inlineStatusLine = lines.find((l) => inlineStatusPattern.test(l));
+    const inlineTypeLine = lines.find((l) => inlineTypePattern.test(l));
+    const inlineAssigneeLine = lines.find((l) => inlineAssigneePattern.test(l));
+    const hasInlineStatus = !!inlineStatusLine;
+    const hasInlineType = !!inlineTypeLine;
+    const hasInlineAssignee = !!inlineAssigneeLine;
+    const endsWithTwoSpaces = (line) => !!line && /\s{2}$/.test(line);
+    const needsSpaceFix = hasInlineStatus && !endsWithTwoSpaces(inlineStatusLine) || hasInlineType && !endsWithTwoSpaces(inlineTypeLine) || hasInlineAssignee && !endsWithTwoSpaces(inlineAssigneeLine);
     if (!hasSectionStatus && !hasSectionType && !hasSectionAssignee && !needsSpaceFix) {
       return false;
     }
@@ -174,23 +179,34 @@ async function fixTaskFile(filePath) {
       wasModified = true;
     }
     if (needsSpaceFix) {
-      newContent = newContent.replace(/^(# .+)\n([^#\n])/m, "$1\n\n$2");
       newContent = newContent.replace(
-        /^(Status|Tipo):\s*(.+?)(\s*)$/im,
+        /^(Status|Tipo):\s*(.+?)([ \t]*)$/im,
         (_, key, value) => `${key}: ${value.trim()}  `
       );
       newContent = newContent.replace(
-        /^(Type|Tipo):\s*(.+?)(\s*)$/im,
+        /^(Type|Tipo):\s*(.+?)([ \t]*)$/im,
         (_, key, value) => `${key}: ${value.trim()}  `
       );
       newContent = newContent.replace(
-        /^(Assignee|Responsável):\s*(.+?)(\s*)$/im,
+        /^(Assignee|Responsável):\s*(.+?)([ \t]*)$/im,
         (_, key, value) => `${key}: ${value.trim()}  `
       );
       wasModified = true;
     }
-    if (wasModified) {
-      const finalContent = newContent.replace(/\n{3,}/g, "\n\n").trim() + "\n";
+    const finalContentRaw = newContent.replace(/\n{3,}/g, "\n\n").trim() + "\n";
+    const originalContentRaw = content.replace(/\n{3,}/g, "\n\n").trim() + "\n";
+    const normalizeForCompare = (s) => s.replace(/(^# .*?)\n+/m, "$1\n\n").trim() + "\n";
+    const finalContent = normalizeForCompare(finalContentRaw);
+    const normalizedOriginal = normalizeForCompare(originalContentRaw);
+    if (filePath.endsWith("/tasks/task-001.md")) {
+      console.debug("DEBUG-NORM COMPARE", {
+        finalContentRaw: finalContentRaw.replace(/\n/g, "\\n"),
+        originalContentRaw: originalContentRaw.replace(/\n/g, "\\n"),
+        finalContent: finalContent.replace(/\n/g, "\\n"),
+        normalizedOriginal: normalizedOriginal.replace(/\n/g, "\\n")
+      });
+    }
+    if (finalContent !== normalizedOriginal) {
       await writeFile(filePath, finalContent, "utf-8");
       return true;
     }
@@ -327,7 +343,7 @@ function createLintResult(allIssues) {
   };
 }
 var init_task_validator = __esm({
-  "../fs-task-provider/dist/task-validator.js"() {
+  "../file-system-task-provider/dist/task-validator.js"() {
     "use strict";
     init_esm_shims();
     init_i18n();
@@ -3549,8 +3565,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path13) {
-      let input = path13;
+    function removeDotSegments(path16) {
+      let input = path16;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3750,8 +3766,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path13, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path13 && path13 !== "/" ? path13 : void 0;
+        const [path16, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -7150,12 +7166,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs3, exportName) {
+    function addFormats(ajv, list, fs5, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs3[f]);
+        ajv.addFormat(f, fs5[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -7170,15 +7186,384 @@ import { Command } from "commander";
 // src/commands/dashboard.ts
 init_esm_shims();
 
-// ../fs-task-provider/dist/index.js
+// ../file-system-task-provider/dist/index.js
 init_esm_shims();
 
-// ../fs-task-provider/dist/fs-task-provider.js
+// ../file-system-task-provider/dist/file-system-metrics-adapter.js
 init_esm_shims();
-init_i18n();
-init_task_validator();
+import { UserStatsSchema } from "@opentask/taskin-types";
 import { promises as fs } from "fs";
 import path2 from "path";
+var MILLISECONDS_PER_SECOND = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+var HOURS_PER_DAY = 24;
+var DAYS_PER_WEEK = 7;
+var MILLISECONDS_PER_DAY = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;
+var TASK_FILENAME_PATTERN = /^task-(\d+)-/;
+var TASK_TITLE_PATTERNS = {
+  withDash: /^# .*?[—-]\s*(.+)$/im,
+  withNumber: /^# .*?\s+(\d+)\s*-\s*(.+)$/im
+};
+function toISOString(date) {
+  return date.toISOString();
+}
+function emptyCodeMetrics() {
+  return {
+    linesAdded: 0,
+    linesRemoved: 0,
+    netChange: 0,
+    characters: 0,
+    filesChanged: 0,
+    commits: 0
+  };
+}
+function emptyTemporalMetrics() {
+  return {
+    byDayOfWeek: {
+      "0": 0,
+      "1": 0,
+      "2": 0,
+      "3": 0,
+      "4": 0,
+      "5": 0,
+      "6": 0
+    },
+    byTimeOfDay: { morning: 0, afternoon: 0, evening: 0, night: 0 },
+    streak: 0,
+    trend: "stable"
+  };
+}
+function removeCodeBlocks(content) {
+  return content.replace(/```[\s\S]*?```/g, "");
+}
+async function calculateCodeMetrics(gitAnalyzer, username, since, until) {
+  if (!gitAnalyzer) {
+    return emptyCodeMetrics();
+  }
+  try {
+    const commits = await gitAnalyzer.getCommits({
+      author: username,
+      since: since.toISOString(),
+      until: until.toISOString()
+    });
+    const metrics = commits.reduce((acc, commit) => ({
+      linesAdded: acc.linesAdded + commit.linesAdded,
+      linesRemoved: acc.linesRemoved + commit.linesRemoved,
+      filesChanged: acc.filesChanged + commit.filesChanged,
+      commits: acc.commits + 1
+    }), {
+      linesAdded: 0,
+      linesRemoved: 0,
+      filesChanged: 0,
+      commits: 0
+    });
+    return {
+      ...metrics,
+      netChange: metrics.linesAdded - metrics.linesRemoved,
+      characters: (metrics.linesAdded + metrics.linesRemoved) * 40
+      // estimate ~40 chars/line
+    };
+  } catch (error2) {
+    console.warn("Failed to calculate code metrics:", error2);
+    return emptyCodeMetrics();
+  }
+}
+async function calculateTemporalMetrics(gitAnalyzer, username, since, until) {
+  if (!gitAnalyzer) {
+    return emptyTemporalMetrics();
+  }
+  try {
+    const commits = await gitAnalyzer.getCommits({
+      author: username,
+      since: since.toISOString(),
+      until: until.toISOString()
+    });
+    const byDayOfWeek = {
+      "0": 0,
+      "1": 0,
+      "2": 0,
+      "3": 0,
+      "4": 0,
+      "5": 0,
+      "6": 0
+    };
+    const byTimeOfDay = { morning: 0, afternoon: 0, evening: 0, night: 0 };
+    const commitsByDate = /* @__PURE__ */ new Map();
+    for (const commit of commits) {
+      const date = new Date(commit.date);
+      const day = date.getDay();
+      const hour = date.getHours();
+      byDayOfWeek[day.toString()]++;
+      if (hour >= 6 && hour < 12)
+        byTimeOfDay.morning++;
+      else if (hour >= 12 && hour < 18)
+        byTimeOfDay.afternoon++;
+      else if (hour >= 18 && hour < 24)
+        byTimeOfDay.evening++;
+      else
+        byTimeOfDay.night++;
+      const dateKey = date.toISOString().split("T")[0];
+      commitsByDate.set(dateKey, (commitsByDate.get(dateKey) || 0) + 1);
+    }
+    const sortedDates = Array.from(commitsByDate.keys()).sort();
+    let currentStreak = 0;
+    let maxStreak = 0;
+    for (let i = 0; i < sortedDates.length; i++) {
+      if (i === 0) {
+        currentStreak = 1;
+      } else {
+        const prevDate = new Date(sortedDates[i - 1]);
+        const currDate = new Date(sortedDates[i]);
+        const daysDiff = (currDate.getTime() - prevDate.getTime()) / (1e3 * 60 * 60 * 24);
+        if (daysDiff === 1) {
+          currentStreak++;
+        } else {
+          currentStreak = 1;
+        }
+      }
+      maxStreak = Math.max(maxStreak, currentStreak);
+    }
+    const midpoint = Math.floor(commits.length / 2);
+    const firstHalf = commits.slice(0, midpoint);
+    const secondHalf = commits.slice(midpoint);
+    const firstHalfAvg = firstHalf.length ? firstHalf.length / Math.max(1, sortedDates.length / 2) : 0;
+    const secondHalfAvg = secondHalf.length ? secondHalf.length / Math.max(1, sortedDates.length / 2) : 0;
+    let trend = "stable";
+    if (secondHalfAvg > firstHalfAvg * 1.2)
+      trend = "increasing";
+    else if (secondHalfAvg < firstHalfAvg * 0.8)
+      trend = "decreasing";
+    return {
+      byDayOfWeek,
+      byTimeOfDay,
+      streak: maxStreak,
+      trend
+    };
+  } catch (error2) {
+    console.warn("Failed to calculate temporal metrics:", error2);
+    return emptyTemporalMetrics();
+  }
+}
+var FileSystemMetricsAdapter = class {
+  tasksDirectory;
+  userRegistry;
+  gitAnalyzer;
+  constructor(tasksDirectory, userRegistry, gitAnalyzer) {
+    this.tasksDirectory = tasksDirectory;
+    this.userRegistry = userRegistry;
+    this.gitAnalyzer = gitAnalyzer;
+  }
+  /**
+   * Reads and parses task files from the filesystem
+   * @returns Array of parsed task file data
+   * @private
+   */
+  async readTaskFiles() {
+    let files;
+    try {
+      files = await fs.readdir(this.tasksDirectory);
+    } catch (error2) {
+      if (error2?.code === "ENOENT") {
+        console.warn(`Tasks directory not found: ${this.tasksDirectory}`);
+        return [];
+      }
+      throw new Error(`Failed to read tasks directory: ${error2?.message || error2}`);
+    }
+    const taskFiles = files.filter((f) => f.startsWith("task-") && f.endsWith(".md"));
+    const tasks = [];
+    for (const file of taskFiles) {
+      const filePath = path2.join(this.tasksDirectory, file);
+      let content;
+      try {
+        content = await fs.readFile(filePath, "utf-8");
+      } catch (error2) {
+        console.warn(`Failed to read task file ${filePath}: ${error2?.message}`);
+        continue;
+      }
+      const idMatch = file.match(TASK_FILENAME_PATTERN);
+      const id = idMatch ? idMatch[1] : file;
+      const titleMatch = content.match(TASK_TITLE_PATTERNS.withDash) || content.match(TASK_TITLE_PATTERNS.withNumber);
+      const title = titleMatch ? titleMatch[1] : file.replace(/\.md$/, "");
+      const contentWithoutCodeBlocks = removeCodeBlocks(content);
+      const extract = (name) => {
+        const rx = new RegExp(`^${name}:\\s*(.+)$`, "im");
+        const m = contentWithoutCodeBlocks.match(rx);
+        return m ? m[1].trim() : void 0;
+      };
+      const statusValue = extract("Status");
+      const assigneeValue = extract("Assignee");
+      const typeValue = extract("Type");
+      const validStatuses = [
+        "pending",
+        "in-progress",
+        "done",
+        "blocked",
+        "canceled"
+      ];
+      const validTypes = [
+        "feat",
+        "fix",
+        "refactor",
+        "docs",
+        "test",
+        "chore"
+      ];
+      const status = validStatuses.includes(statusValue) ? statusValue : void 0;
+      const type = validTypes.includes(typeValue) ? typeValue : void 0;
+      tasks.push({
+        id,
+        title,
+        status,
+        assignee: assigneeValue,
+        type,
+        filePath
+      });
+    }
+    return tasks;
+  }
+  async getUserMetrics(userId, _query) {
+    const user = this.userRegistry.getUser(userId);
+    const username = user ? user.name : userId;
+    const now = /* @__PURE__ */ new Date();
+    const weekAgo = new Date(Date.now() - DAYS_PER_WEEK * MILLISECONDS_PER_DAY);
+    const tasks = await this.readTaskFiles();
+    const assigned = tasks.filter((t) => {
+      if (!t.assignee)
+        return false;
+      return t.assignee === user?.id || t.assignee === user?.name || t.assignee === username;
+    });
+    const completed = assigned.filter((t) => t.status === "done").length;
+    const active = assigned.filter((t) => t.status !== "done").length;
+    const codeMetrics = await calculateCodeMetrics(this.gitAnalyzer, username, weekAgo, now);
+    const temporalMetrics = await calculateTemporalMetrics(this.gitAnalyzer, username, weekAgo, now);
+    const rawMetrics = {
+      username,
+      period: "week",
+      periodStart: toISOString(weekAgo),
+      periodEnd: toISOString(now),
+      codeMetrics,
+      temporalMetrics,
+      contributionMetrics: {
+        totalCommits: codeMetrics.commits,
+        tasksCompleted: completed,
+        averageCompletionTime: 0,
+        // TODO: calculate from task timestamps
+        taskTypeDistribution: {},
+        // TODO: calculate from task types
+        activityFrequency: codeMetrics.commits / DAYS_PER_WEEK
+        // commits per day
+      },
+      engagementMetrics: {
+        commitsPerDay: codeMetrics.commits / DAYS_PER_WEEK,
+        consistency: 0,
+        // TODO: calculate standard deviation
+        activeTasksCount: active,
+        completionRate: assigned.length ? completed / assigned.length : 0
+      },
+      topTasks: []
+    };
+    return UserStatsSchema.parse(rawMetrics);
+  }
+  async getTeamMetrics(_teamId, _query) {
+    const now = /* @__PURE__ */ new Date();
+    const weekAgo = new Date(Date.now() - DAYS_PER_WEEK * MILLISECONDS_PER_DAY);
+    const tasks = await this.readTaskFiles();
+    const contributors = /* @__PURE__ */ new Map();
+    for (const t of tasks) {
+      const assignee = t.assignee || "unknown";
+      const prev = contributors.get(assignee) || {
+        username: assignee,
+        commits: 0,
+        tasksCompleted: 0,
+        codeMetrics: emptyCodeMetrics()
+      };
+      if (t.status === "done")
+        prev.tasksCompleted += 1;
+      contributors.set(assignee, prev);
+    }
+    for (const [username, data] of contributors.entries()) {
+      try {
+        const codeMetrics = await calculateCodeMetrics(this.gitAnalyzer, username, weekAgo, now);
+        data.commits = codeMetrics.commits;
+        data.codeMetrics = codeMetrics;
+      } catch (error2) {
+        console.error(`Failed to calculate metrics for ${username}:`, error2);
+      }
+    }
+    const totalCommits = Array.from(contributors.values()).reduce((sum, c) => sum + c.commits, 0);
+    const totalTasksCompleted = Array.from(contributors.values()).reduce((sum, c) => sum + c.tasksCompleted, 0);
+    const aggregatedCodeMetrics = Array.from(contributors.values()).reduce((acc, c) => ({
+      linesAdded: acc.linesAdded + c.codeMetrics.linesAdded,
+      linesRemoved: acc.linesRemoved + c.codeMetrics.linesRemoved,
+      netChange: acc.netChange + c.codeMetrics.netChange,
+      characters: acc.characters + c.codeMetrics.characters,
+      filesChanged: acc.filesChanged + c.codeMetrics.filesChanged,
+      commits: acc.commits + c.codeMetrics.commits
+    }), emptyCodeMetrics());
+    const team = {
+      period: "week",
+      periodStart: toISOString(weekAgo),
+      periodEnd: toISOString(now),
+      totalContributors: contributors.size,
+      totalCommits,
+      totalTasksCompleted,
+      codeMetrics: aggregatedCodeMetrics,
+      contributors: Array.from(contributors.values()).map((c) => ({
+        username: c.username,
+        commits: c.commits,
+        tasksCompleted: c.tasksCompleted,
+        codeMetrics: c.codeMetrics
+      })),
+      taskTypeDistribution: {}
+    };
+    return team;
+  }
+  async getTaskMetrics(taskId, _query) {
+    const tasks = await this.readTaskFiles();
+    const found = tasks.find((t) => t.id === taskId || t.filePath.includes(taskId));
+    const now = /* @__PURE__ */ new Date();
+    const validStatuses = [
+      "pending",
+      "in-progress",
+      "done",
+      "blocked",
+      "canceled"
+    ];
+    const base = {
+      taskId,
+      title: found ? found.title : taskId,
+      type: found && found.type || "feat",
+      status: found?.status && validStatuses.includes(found.status) ? found.status : "pending",
+      assignee: found?.assignee,
+      duration: 0,
+      created: toISOString(now),
+      contributors: [],
+      codeMetrics: emptyCodeMetrics(),
+      refactoringMetrics: void 0,
+      temporalMetrics: emptyTemporalMetrics(),
+      workPattern: { mostActiveTimeOfDay: "morning", daysWorked: 0, gaps: 0 },
+      commitHistory: {
+        totalCommits: 0,
+        averageCommitSize: 0,
+        largestCommit: { linesAdded: 0, linesRemoved: 0 },
+        smallestCommit: { linesAdded: 0, linesRemoved: 0 }
+      },
+      firstCommit: void 0,
+      lastCommit: void 0,
+      statusChangedToDone: void 0,
+      createdAt: void 0
+    };
+    return base;
+  }
+};
+
+// ../file-system-task-provider/dist/fs-task-provider.js
+init_esm_shims();
+init_i18n();
+init_task_validator();
+import { promises as fs2 } from "fs";
+import path3 from "path";
 var FileSystemTaskProvider = class {
   tasksDirectory;
   userRegistry;
@@ -7189,15 +7574,15 @@ var FileSystemTaskProvider = class {
     this.locale = locale;
   }
   async findTask(taskId) {
-    const files = await fs.readdir(this.tasksDirectory);
+    const files = await fs2.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 filePath = path3.join(this.tasksDirectory, taskFile);
+    const content = await fs2.readFile(filePath, "utf-8");
     const titleMatch = content.match(/^# .*Task.*?[—-]\s*(.+)$/im);
     const title = titleMatch ? titleMatch[1].trim() : "Untitled";
     const contentLocale = detectLocale(content);
@@ -7239,7 +7624,7 @@ var FileSystemTaskProvider = class {
     return task;
   }
   async updateTask(task) {
-    const currentContent = await fs.readFile(task.filePath, "utf-8");
+    const currentContent = await fs2.readFile(task.filePath, "utf-8");
     const hasSectionMetadata = /##\s*(Status|Type|Assignee)/i.test(
       currentContent
     );
@@ -7247,31 +7632,31 @@ var FileSystemTaskProvider = class {
       const { fixTaskFile: fixTaskFile2 } = await Promise.resolve().then(() => (init_task_validator(), task_validator_exports));
       await fixTaskFile2(task.filePath);
     }
-    const content = await fs.readFile(task.filePath, "utf-8");
+    const content = await fs2.readFile(task.filePath, "utf-8");
     let updatedContent;
     if (/^Status:\s*.+$/im.test(content)) {
       updatedContent = content.replace(
         /^Status:\s*.+$/im,
-        `Status: ${task.status}  `
+        `Status: ${task.status}`
       );
     } else {
       updatedContent = content.replace(
         /(^#.*\n)/,
-        `$1Status: ${task.status}  
+        `$1Status: ${task.status}
 `
       );
     }
-    await fs.writeFile(task.filePath, updatedContent, "utf-8");
+    await fs2.writeFile(task.filePath, updatedContent, "utf-8");
   }
   async getAllTasks() {
-    const files = await fs.readdir(this.tasksDirectory);
+    const files = await fs2.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 filePath = path3.join(this.tasksDirectory, file);
+      const content = await fs2.readFile(filePath, "utf-8");
       const idMatch = file.match(/^task-(\d+)-/);
       const taskId = idMatch ? idMatch[1] : "unknown";
       const titleMatch = content.match(/^# .*Task.*?[—-]\s*(.+)$/im);
@@ -7329,8 +7714,8 @@ var FileSystemTaskProvider = class {
     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 = path2.join(this.tasksDirectory, fileName);
-    const fileExists = await fs.access(filePath).then(() => true).catch(() => false);
+    const filePath = path3.join(this.tasksDirectory, fileName);
+    const fileExists = await fs2.access(filePath).then(() => true).catch(() => false);
     if (fileExists) {
       throw new Error(`Task file already exists: ${fileName}`);
     }
@@ -7349,7 +7734,7 @@ var FileSystemTaskProvider = class {
       assignee: assignee?.name || i18n.defaultAssignee,
       i18n
     });
-    await fs.writeFile(filePath, taskContent, "utf-8");
+    await fs2.writeFile(filePath, taskContent, "utf-8");
     const task = await this.findTask(taskId);
     if (!task) {
       throw new Error(`Failed to create task ${taskId}`);
@@ -7381,8 +7766,8 @@ ${i18n.notesPlaceholder}
 `;
   }
   async lint(fix) {
-    const files = await fs.readdir(this.tasksDirectory);
-    const taskFiles = files.filter((file) => file.startsWith("task-") && file.endsWith(".md")).map((file) => path2.join(this.tasksDirectory, file));
+    const files = await fs2.readdir(this.tasksDirectory);
+    const taskFiles = files.filter((file) => file.startsWith("task-") && file.endsWith(".md")).map((file) => path3.join(this.tasksDirectory, file));
     if (fix) {
       let fixedCount = 0;
       for (const filePath of taskFiles) {
@@ -7404,27 +7789,27 @@ ${i18n.notesPlaceholder}
   }
 };
 
-// ../fs-task-provider/dist/index.js
+// ../file-system-task-provider/dist/index.js
 init_i18n();
 
-// ../fs-task-provider/dist/user-registry.js
+// ../file-system-task-provider/dist/user-registry.js
 init_esm_shims();
-import { promises as fs2 } from "fs";
-import path3 from "path";
+import { promises as fs3 } from "fs";
+import path4 from "path";
 var UserRegistry = class {
   config;
   users = /* @__PURE__ */ new Map();
   usersFilePath;
   constructor(config) {
     this.config = config;
-    this.usersFilePath = path3.join(config.taskinDir, "users.json");
+    this.usersFilePath = path4.join(config.taskinDir, "users.json");
   }
   /**
    * Load users from users.json
    */
   async load() {
     try {
-      const content = await fs2.readFile(this.usersFilePath, "utf-8");
+      const content = await fs3.readFile(this.usersFilePath, "utf-8");
       const data = JSON.parse(content);
       this.users.clear();
       for (const [id, user] of Object.entries(data.users)) {
@@ -7497,7 +7882,7 @@ var UserRegistry = class {
     const data = {
       users: Object.fromEntries(this.users.entries())
     };
-    await fs2.writeFile(
+    await fs3.writeFile(
       this.usersFilePath,
       JSON.stringify(data, null, 2),
       "utf-8"
@@ -7906,41 +8291,38 @@ init_esm_shims();
 // ../utils/dist/security.js
 init_esm_shims();
 import { z } from "zod";
-var HostSchema = z.string().refine(
-  (host) => {
-    if (!host || host.length === 0) return false;
-    if (host === "localhost") return true;
-    const parts = host.split(".");
-    const allNumeric = parts.every((p) => /^\d+$/.test(p));
-    if (allNumeric) {
-      if (parts.length !== 4) return false;
-      return parts.every((part) => {
-        const num = parseInt(part, 10);
-        return !isNaN(num) && num >= 0 && num <= 255 && part === num.toString();
-      });
-    }
-    const hostnameRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-    return hostnameRegex.test(host);
-  },
-  {
-    message: "Invalid host. Must be localhost, a valid IPv4 address, or hostname."
+var HostSchema = z.string().refine((host) => {
+  if (!host || host.length === 0)
+    return false;
+  if (host === "localhost")
+    return true;
+  const parts = host.split(".");
+  const allNumeric = parts.every((p) => /^\d+$/.test(p));
+  if (allNumeric) {
+    if (parts.length !== 4)
+      return false;
+    return parts.every((part) => {
+      const num = parseInt(part, 10);
+      return !isNaN(num) && num >= 0 && num <= 255 && part === num.toString();
+    });
   }
-);
+  const hostnameRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+  return hostnameRegex.test(host);
+}, {
+  message: "Invalid host. Must be localhost, a valid IPv4 address, or hostname."
+});
 var PortSchema = z.union([
   z.number().int().min(1).max(65535),
   z.string().regex(/^\d+$/).transform((val) => parseInt(val, 10)).pipe(z.number().int().min(1).max(65535))
 ]);
-var WebSocketUrlSchema = z.string().refine(
-  (url) => {
-    try {
-      const parsed = new URL(url);
-      return parsed.protocol === "ws:" || parsed.protocol === "wss:";
-    } catch {
-      return false;
-    }
-  },
-  { message: "Invalid WebSocket URL. Must use ws:// or wss:// protocol." }
-);
+var WebSocketUrlSchema = z.string().refine((url) => {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "ws:" || parsed.protocol === "wss:";
+  } catch {
+    return false;
+  }
+}, { message: "Invalid WebSocket URL. Must use ws:// or wss:// protocol." });
 var TaskIdSchema = z.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/, {
   message: "Task ID must contain only alphanumeric characters, hyphens, and underscores."
 });
@@ -7948,25 +8330,23 @@ var UserIdSchema = z.string().min(1).max(100).regex(/^[a-zA-Z0-9._-]+$/, {
   message: "User ID must contain only alphanumeric characters, dots, hyphens, and underscores."
 });
 var EmailSchema = z.string().email().max(254);
-var SafePathSchema = z.string().refine(
-  (filePath) => {
-    if (!filePath || filePath.length === 0) return false;
-    const dangerousPatterns = [
-      /\.\./,
-      // Parent directory (..)
-      /~\//,
-      // Home directory
-      /^\//,
-      // Absolute path
-      /^[A-Za-z]:\\/
-      // Windows absolute path
-    ];
-    return !dangerousPatterns.some((pattern) => pattern.test(filePath));
-  },
-  {
-    message: "Invalid path. Must be a relative path without traversal patterns."
-  }
-);
+var SafePathSchema = z.string().refine((filePath) => {
+  if (!filePath || filePath.length === 0)
+    return false;
+  const dangerousPatterns = [
+    /\.\./,
+    // Parent directory (..)
+    /~\//,
+    // Home directory
+    /^\//,
+    // Absolute path
+    /^[A-Za-z]:\\/
+    // Windows absolute path
+  ];
+  return !dangerousPatterns.some((pattern) => pattern.test(filePath));
+}, {
+  message: "Invalid path. Must be a relative path without traversal patterns."
+});
 var DashboardOptionsSchema = z.object({
   host: HostSchema.optional(),
   port: PortSchema.optional(),
@@ -8011,7 +8391,7 @@ var colors = {
 import chalk3 from "chalk";
 import express from "express";
 import { createServer } from "http";
-import path5 from "path";
+import path6 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/colors.ts
@@ -8055,9 +8435,9 @@ function info(message) {
 // src/lib/project-check.ts
 init_esm_shims();
 import { existsSync } from "fs";
-import path4 from "path";
+import path5 from "path";
 function isTaskinProject(cwd = process.cwd()) {
-  return existsSync(path4.join(cwd, ".taskin.json"));
+  return existsSync(path5.join(cwd, ".taskin.json"));
 }
 function requireTaskinProject(cwd = process.cwd()) {
   if (!isTaskinProject(cwd)) {
@@ -8100,7 +8480,7 @@ init_esm_shims();
 
 // src/commands/dashboard.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path5.dirname(__filename2);
+var __dirname2 = path6.dirname(__filename2);
 var dashboardCommand = defineCommand({
   name: "dashboard",
   description: "\u{1F4CA} Start the Taskin dashboard with WebSocket server",
@@ -8168,24 +8548,24 @@ async function startDashboard(options) {
   try {
     info("Initializing task provider...");
     let currentDir = process.cwd();
-    let tasksDir = path5.join(currentDir, "TASKS");
+    let tasksDir = path6.join(currentDir, "TASKS");
     try {
-      await import("fs").then((fs3) => fs3.promises.access(tasksDir));
+      await import("fs").then((fs5) => fs5.promises.access(tasksDir));
     } catch {
-      while (currentDir !== path5.dirname(currentDir)) {
-        const workspaceFile = path5.join(currentDir, "pnpm-workspace.yaml");
+      while (currentDir !== path6.dirname(currentDir)) {
+        const workspaceFile = path6.join(currentDir, "pnpm-workspace.yaml");
         try {
-          await import("fs").then((fs3) => fs3.promises.access(workspaceFile));
-          tasksDir = path5.join(currentDir, "TASKS");
+          await import("fs").then((fs5) => fs5.promises.access(workspaceFile));
+          tasksDir = path6.join(currentDir, "TASKS");
           break;
         } catch {
-          currentDir = path5.dirname(currentDir);
+          currentDir = path6.dirname(currentDir);
         }
       }
     }
     info(`Using tasks directory: ${tasksDir}`);
-    const monorepoRoot = path5.dirname(tasksDir);
-    const taskinDir = path5.join(monorepoRoot, ".taskin");
+    const monorepoRoot = path6.dirname(tasksDir);
+    const taskinDir = path6.join(monorepoRoot, ".taskin");
     const userRegistry = new UserRegistry({ taskinDir });
     await userRegistry.load();
     const provider = new FileSystemTaskProvider(tasksDir, userRegistry);
@@ -8203,7 +8583,7 @@ async function startDashboard(options) {
     success(`\u2713 WebSocket server running on ws://${host}:${wsPort}`);
     info(`Starting dashboard server on http://${host}:${port}...`);
     const isDev = __dirname2.includes("/src/");
-    const dashboardDist = isDev ? path5.join(__dirname2, "..", "..", "dashboard-dist") : path5.join(__dirname2, "..", "dashboard-dist");
+    const dashboardDist = isDev ? path6.join(__dirname2, "..", "..", "dashboard-dist") : path6.join(__dirname2, "..", "dashboard-dist");
     const app = express();
     app.disable("x-powered-by");
     app.use((req, res, next) => {
@@ -8219,8 +8599,8 @@ async function startDashboard(options) {
     app.use((req, res, next) => {
       if (req.path === "/" || req.path === "/index.html") {
         import("fs").then(
-          (fs3) => fs3.promises.readFile(
-            path5.join(dashboardDist, "index.html"),
+          (fs5) => fs5.promises.readFile(
+            path6.join(dashboardDist, "index.html"),
             "utf-8"
           )
         ).then((html) => {
@@ -8292,25 +8672,428 @@ async function startDashboard(options) {
   }
 }
 
-// src/commands/finish.ts
+// src/commands/export.ts
+init_esm_shims();
+
+// ../git-utils/dist/src/index.js
 init_esm_shims();
+
+// ../git-utils/dist/src/git.js
+init_esm_shims();
+
+// ../git-utils/dist/src/git-analyzer.js
+init_esm_shims();
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+function isNodeError(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2;
+}
+async function executeGit(command, cwd) {
+  try {
+    const { stdout } = await execAsync(`git ${command}`, {
+      cwd: cwd || process.cwd(),
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB buffer for large repos
+    });
+    return stdout.trim();
+  } catch (error2) {
+    if (isNodeError(error2)) {
+      if (error2.code === "ENOENT") {
+        throw new Error("Git is not installed or not in PATH");
+      }
+    }
+    return "";
+  }
+}
+var GitAnalyzer = class {
+  repositoryPath;
+  constructor(repositoryPath) {
+    this.repositoryPath = repositoryPath;
+  }
+  async isValidRepository() {
+    try {
+      const result = await executeGit("rev-parse --is-inside-work-tree", this.repositoryPath);
+      return result === "true";
+    } catch {
+      return false;
+    }
+  }
+  async getRepositoryRoot() {
+    const result = await executeGit("rev-parse --show-toplevel", this.repositoryPath);
+    if (!result) {
+      throw new Error("Not a git repository");
+    }
+    return result;
+  }
+  async getCommits(options = {}) {
+    const args = ["log"];
+    args.push("--pretty='format:%H|%an|%aI|%s%x00%b'", "--numstat");
+    if (options.since) {
+      args.push(`--since="${options.since}"`);
+    }
+    if (options.until) {
+      args.push(`--until="${options.until}"`);
+    }
+    if (options.author) {
+      args.push(`--author="${options.author}"`);
+    }
+    if (options.maxCount) {
+      args.push(`-n ${options.maxCount}`);
+    }
+    if (!options.includeMerges) {
+      args.push("--no-merges");
+    }
+    if (options.filePath) {
+      args.push("--", options.filePath);
+    }
+    const command = args.join(" ");
+    const output = await executeGit(command, this.repositoryPath);
+    if (!output) {
+      return [];
+    }
+    return this.parseCommits(output);
+  }
+  parseCommits(output) {
+    const commits = [];
+    const lines = output.split("\n");
+    let i = 0;
+    while (i < lines.length) {
+      const line = lines[i];
+      if (!line.trim()) {
+        i++;
+        continue;
+      }
+      if (line.includes("|")) {
+        const parts = line.split("|");
+        if (parts.length < 4 || !/^[0-9a-f]{40}$/.test(parts[0])) {
+          i++;
+          continue;
+        }
+        const [hash, author, date, messageWithBody] = parts;
+        const nullByteIndex = messageWithBody?.indexOf("\0") ?? -1;
+        const subject = nullByteIndex !== -1 ? messageWithBody.substring(0, nullByteIndex) : messageWithBody || "";
+        let bodyLines = [];
+        if (nullByteIndex !== -1) {
+          bodyLines.push(messageWithBody.substring(nullByteIndex + 1));
+        }
+        i++;
+        while (i < lines.length && !lines[i].includes("|") && !lines[i].includes("	")) {
+          if (lines[i].trim()) {
+            bodyLines.push(lines[i]);
+          }
+          i++;
+        }
+        const body = bodyLines.join("\n");
+        const fullMessage = body ? `${subject}
+
+${body}` : subject;
+        let filesChanged = 0;
+        let linesAdded = 0;
+        let linesRemoved = 0;
+        while (i < lines.length && !lines[i].includes("|")) {
+          const statLine = lines[i].trim();
+          if (!statLine) {
+            i++;
+            continue;
+          }
+          const [added, removed] = statLine.split("	");
+          if (added !== "-" && removed !== "-") {
+            linesAdded += parseInt(added || "0", 10);
+            linesRemoved += parseInt(removed || "0", 10);
+            filesChanged++;
+          }
+          i++;
+        }
+        commits.push({
+          hash,
+          author,
+          date,
+          message: subject,
+          filesChanged,
+          linesAdded,
+          linesRemoved,
+          coAuthors: this.extractCoAuthors(fullMessage)
+        });
+      } else {
+        i++;
+      }
+    }
+    return commits;
+  }
+  extractCoAuthors(message) {
+    const coAuthorRegex = /Co-authored-by:\s*(.+?)\s*<(.+?)>/gi;
+    const matches = Array.from(message.matchAll(coAuthorRegex));
+    if (matches.length === 0) {
+      return void 0;
+    }
+    return matches.map((match) => match[1].trim());
+  }
+  async getDiff(from = "HEAD", to = "") {
+    const args = ["diff", "--numstat"];
+    if (to) {
+      args.push(`${from}..${to}`);
+    } else {
+      args.push(from);
+    }
+    const output = await executeGit(args.join(" "), this.repositoryPath);
+    return this.parseDiff(output);
+  }
+  parseDiff(output) {
+    const files = [];
+    let totalLinesAdded = 0;
+    let totalLinesRemoved = 0;
+    if (!output) {
+      return {
+        files,
+        totalLinesAdded,
+        totalLinesRemoved,
+        netChange: 0
+      };
+    }
+    const lines = output.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      const parts = line.split("	");
+      if (parts.length < 3)
+        continue;
+      const [added, removed, path16] = parts;
+      if (added === "-" || removed === "-") {
+        continue;
+      }
+      const linesAdded = parseInt(added, 10);
+      const linesRemoved = parseInt(removed, 10);
+      totalLinesAdded += linesAdded;
+      totalLinesRemoved += linesRemoved;
+      files.push({
+        path: path16,
+        linesAdded,
+        linesRemoved,
+        changeType: "modified"
+        // Simplified - could be enhanced with --name-status
+      });
+    }
+    return {
+      files,
+      totalLinesAdded,
+      totalLinesRemoved,
+      netChange: totalLinesAdded - totalLinesRemoved
+    };
+  }
+  async getFileDiff(filePath, from = "HEAD", to = "") {
+    const args = ["diff", "--numstat"];
+    if (to) {
+      args.push(`${from}..${to}`);
+    } else {
+      args.push(from);
+    }
+    args.push("--", filePath);
+    const output = await executeGit(args.join(" "), this.repositoryPath);
+    if (!output) {
+      return null;
+    }
+    const [added, removed, path16] = output.split("	");
+    if (added === "-" || removed === "-") {
+      return null;
+    }
+    return {
+      path: path16,
+      linesAdded: parseInt(added, 10),
+      linesRemoved: parseInt(removed, 10),
+      changeType: "modified"
+    };
+  }
+  async getBlame(filePath) {
+    const args = ["blame", "--line-porcelain", filePath];
+    const output = await executeGit(args.join(" "), this.repositoryPath);
+    if (!output) {
+      return [];
+    }
+    return this.parseBlame(output);
+  }
+  parseBlame(output) {
+    const lines = output.split("\n");
+    const blameInfo = [];
+    let currentHash = "";
+    let currentAuthor = "";
+    let currentDate = "";
+    let lineNumber = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.match(/^[0-9a-f]{40}/)) {
+        const parts = line.split(" ");
+        currentHash = parts[0];
+        lineNumber = parseInt(parts[2], 10);
+      } else if (line.startsWith("author ")) {
+        currentAuthor = line.substring(7);
+      } else if (line.startsWith("author-time ")) {
+        const timestamp = parseInt(line.substring(12), 10);
+        currentDate = new Date(timestamp * 1e3).toISOString();
+      } else if (line.startsWith("	")) {
+        const content = line.substring(1);
+        blameInfo.push({
+          lineNumber,
+          commitHash: currentHash,
+          author: currentAuthor,
+          date: new Date(currentDate),
+          content
+        });
+      }
+    }
+    return blameInfo;
+  }
+  async getAuthors(options = {}) {
+    const args = ["shortlog", "-sne"];
+    if (options.since) {
+      args.push(`--since="${options.since}"`);
+    }
+    if (options.until) {
+      args.push(`--until="${options.until}"`);
+    }
+    if (!options.includeMerges) {
+      args.push("--no-merges");
+    }
+    if (options.filePath) {
+      args.push("--", options.filePath);
+    }
+    const output = await executeGit(args.join(" "), this.repositoryPath);
+    if (!output) {
+      return [];
+    }
+    return this.parseAuthors(output);
+  }
+  parseAuthors(output) {
+    const lines = output.split("\n").filter((l) => l.trim());
+    const authors = [];
+    for (const line of lines) {
+      const match = line.match(/^\s*(\d+)\s+(.+?)\s+<(.+?)>/);
+      if (match) {
+        const [, commits, name, email] = match;
+        authors.push({
+          name,
+          email,
+          commits: parseInt(commits, 10)
+        });
+      }
+    }
+    return authors;
+  }
+  async getFileHistory(filePath, options = {}) {
+    return this.getCommits({
+      ...options,
+      filePath
+    });
+  }
+};
+
+// ../git-utils/dist/src/git-analyzer.types.js
+init_esm_shims();
+
+// ../git-utils/dist/src/git.types.js
+init_esm_shims();
+
+// src/commands/export.ts
+import fs4 from "fs/promises";
 import path7 from "path";
+function userStatsToCsv(stats) {
+  const headers = [
+    "username",
+    "period",
+    "period_start",
+    "period_end",
+    "commits",
+    "lines_added",
+    "lines_removed",
+    "net_change",
+    "files_changed",
+    "tasks_completed",
+    "completion_rate",
+    "commits_per_day",
+    "streak",
+    "trend"
+  ].join(",");
+  const values = [
+    stats.username,
+    stats.period,
+    stats.periodStart,
+    stats.periodEnd,
+    stats.codeMetrics.commits,
+    stats.codeMetrics.linesAdded,
+    stats.codeMetrics.linesRemoved,
+    stats.codeMetrics.netChange,
+    stats.codeMetrics.filesChanged,
+    stats.contributionMetrics.tasksCompleted,
+    stats.engagementMetrics.completionRate.toFixed(2),
+    stats.engagementMetrics.commitsPerDay.toFixed(2),
+    stats.temporalMetrics.streak,
+    stats.temporalMetrics.trend
+  ].join(",");
+  return `${headers}
+${values}`;
+}
+function registerExportCommand(program2) {
+  program2.command("export").description("Export metrics to CSV or JSON").option("-u, --user <username>", "User to export metrics for").option("-f, --format <format>", "Output format (csv|json)", "json").option("-o, --output <file>", "Output file path").option("-p, --period <period>", "Time period (day|week|month)", "week").action(async (options) => {
+    try {
+      const cwd = process.cwd();
+      const tasksDir = path7.join(cwd, "TASKS");
+      try {
+        await fs4.access(tasksDir);
+      } catch {
+        console.error("\u274C TASKS directory not found in current directory");
+        process.exit(1);
+      }
+      const gitAnalyzer = new GitAnalyzer(cwd);
+      const userRegistry = new UserRegistry({
+        taskinDir: path7.join(cwd, ".taskin")
+      });
+      await userRegistry.load();
+      const metricsAdapter = new FileSystemMetricsAdapter(
+        tasksDir,
+        userRegistry,
+        gitAnalyzer
+      );
+      const username = options.user || process.env.USER || "unknown";
+      const stats = await metricsAdapter.getUserMetrics(username, {
+        period: options.period
+      });
+      let output;
+      if (options.format === "csv") {
+        output = userStatsToCsv(stats);
+      } else {
+        output = JSON.stringify(stats, null, 2);
+      }
+      if (options.output) {
+        await fs4.writeFile(options.output, output, "utf-8");
+        console.log(`\u2705 Metrics exported to ${options.output}`);
+      } else {
+        console.log(output);
+      }
+    } catch (error2) {
+      console.error("\u274C Error exporting metrics:", error2);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/finish.ts
+init_esm_shims();
+import path9 from "path";
 
 // src/lib/sound-player.ts
 init_esm_shims();
 import { existsSync as existsSync2 } from "fs";
-import path6 from "path";
+import path8 from "path";
 import player from "play-sound";
 var soundPlayer = player({});
 function playSound(soundName) {
   try {
     const possiblePaths = [
       // In development (from src)
-      path6.join(process.cwd(), "packages", "cli", "sounds", `${soundName}.mp3`),
+      path8.join(process.cwd(), "packages", "cli", "sounds", `${soundName}.mp3`),
       // In production (relative to dist)
-      path6.join(__dirname, "..", "sounds", `${soundName}.mp3`),
+      path8.join(__dirname, "..", "sounds", `${soundName}.mp3`),
       // Custom sound in project root
-      path6.join(process.cwd(), ".taskin", `${soundName}.mp3`)
+      path8.join(process.cwd(), ".taskin", `${soundName}.mp3`)
     ];
     const soundPath = possiblePaths.find((p) => existsSync2(p));
     if (!soundPath) {
@@ -8348,9 +9131,9 @@ async function finishTask(taskId, options) {
   requireTaskinProject();
   printHeader(`Finishing Task ${taskId}`, "\u2705");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path7.join(process.cwd(), "TASKS");
-  const monorepoRoot = path7.dirname(tasksDir);
-  const taskinDir = path7.join(monorepoRoot, ".taskin");
+  const tasksDir = path9.join(process.cwd(), "TASKS");
+  const monorepoRoot = path9.dirname(tasksDir);
+  const taskinDir = path9.join(monorepoRoot, ".taskin");
   const userRegistry = new UserRegistry({ taskinDir });
   await userRegistry.load();
   const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
@@ -8424,7 +9207,7 @@ function detectPackageManager() {
 }
 function isBundledProvider(packageName) {
   const bundledProviders = [
-    "@opentask/taskin-fs-provider",
+    "@opentask/taskin-file-system-provider",
     "@opentask/taskin-core",
     "@opentask/taskin-task-manager",
     "@opentask/taskin-git-utils",
@@ -8501,7 +9284,7 @@ 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",
+    packageName: "@opentask/taskin-file-system-provider",
     configSchema: {
       required: ["tasksDir"],
       properties: {
@@ -8848,7 +9631,7 @@ async function executeLint(options) {
 
 // src/commands/list.ts
 init_esm_shims();
-import path8 from "path";
+import path10 from "path";
 var listCommand = defineCommand({
   name: "list [filter]",
   description: "\u{1F4CA} List all tasks in the project",
@@ -8874,9 +9657,9 @@ var listCommand = defineCommand({
 async function listTasks(filter, options) {
   requireTaskinProject();
   printHeader("Task List", "\u{1F4CA}");
-  const tasksDir = path8.join(process.cwd(), "TASKS");
-  const monorepoRoot = path8.dirname(tasksDir);
-  const taskinDir = path8.join(monorepoRoot, ".taskin");
+  const tasksDir = path10.join(process.cwd(), "TASKS");
+  const monorepoRoot = path10.dirname(tasksDir);
+  const taskinDir = path10.join(monorepoRoot, ".taskin");
   const userRegistry = new UserRegistry({ taskinDir });
   await userRegistry.load();
   const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
@@ -12697,7 +13480,7 @@ init_esm_shims();
 
 // src/commands/mcp-server.ts
 import chalk5 from "chalk";
-import path9 from "path";
+import path11 from "path";
 var mcpServerCommand = defineCommand({
   name: "mcp-server",
   description: "\u{1F916} Start Model Context Protocol server for LLM integration",
@@ -12724,9 +13507,9 @@ async function startMCPServer(options) {
   printHeader("Starting MCP Server", "\u{1F916}");
   try {
     info("Initializing task manager...");
-    const tasksDir = path9.join(process.cwd(), "TASKS");
-    const monorepoRoot = path9.dirname(tasksDir);
-    const taskinDir = path9.join(monorepoRoot, ".taskin");
+    const tasksDir = path11.join(process.cwd(), "TASKS");
+    const monorepoRoot = path11.dirname(tasksDir);
+    const taskinDir = path11.join(monorepoRoot, ".taskin");
     const userRegistry = new UserRegistry({ taskinDir });
     await userRegistry.load();
     const provider = new FileSystemTaskProvider(tasksDir, userRegistry);
@@ -12789,7 +13572,7 @@ async function startMCPServer(options) {
 init_esm_shims();
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import inquirer2 from "inquirer";
-import path10 from "path";
+import path12 from "path";
 var createCommand = defineCommand({
   name: "new",
   description: "\u2795 Create a new task",
@@ -12881,12 +13664,12 @@ async function createTask(options) {
     );
     return;
   }
-  const tasksDir = path10.join(process.cwd(), "TASKS");
+  const tasksDir = path12.join(process.cwd(), "TASKS");
   if (!existsSync5(tasksDir)) {
     mkdirSync2(tasksDir, { recursive: true });
   }
-  const monorepoRoot = path10.dirname(tasksDir);
-  const taskinDir = path10.join(monorepoRoot, ".taskin");
+  const monorepoRoot = path12.dirname(tasksDir);
+  const taskinDir = path12.join(monorepoRoot, ".taskin");
   const userRegistry = new UserRegistry({ taskinDir });
   await userRegistry.load();
   const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
@@ -12899,7 +13682,7 @@ async function createTask(options) {
   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 = path10.join(tasksDir, fileName);
+  const filePath = path12.join(tasksDir, fileName);
   if (existsSync5(filePath)) {
     error(`Task file already exists: ${fileName}`);
     return;
@@ -12952,7 +13735,7 @@ Add any relevant notes or links here.
 // src/commands/pause.ts
 init_esm_shims();
 import { execSync as execSync2 } from "child_process";
-import path11 from "path";
+import path13 from "path";
 var pauseCommand = defineCommand({
   name: "pause <task-id>",
   description: "\u23F8\uFE0F  Pause work on a task",
@@ -12979,9 +13762,9 @@ async function pauseTask(taskId, options) {
   requireTaskinProject();
   printHeader(`Pausing Task ${taskId}`, "\u23F8\uFE0F");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path11.join(process.cwd(), "TASKS");
-  const monorepoRoot = path11.dirname(tasksDir);
-  const taskinDir = path11.join(monorepoRoot, ".taskin");
+  const tasksDir = path13.join(process.cwd(), "TASKS");
+  const monorepoRoot = path13.dirname(tasksDir);
+  const taskinDir = path13.join(monorepoRoot, ".taskin");
   const userRegistry = new UserRegistry({ taskinDir });
   await userRegistry.load();
   const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
@@ -13034,7 +13817,7 @@ async function pauseTask(taskId, options) {
 
 // src/commands/start.ts
 init_esm_shims();
-import path12 from "path";
+import path14 from "path";
 var startCommand = defineCommand({
   name: "start <task-id>",
   description: "\u{1F680} Start working on a task",
@@ -13061,9 +13844,9 @@ async function startTask(taskId, _options) {
   requireTaskinProject();
   printHeader(`Starting Task ${taskId}`, "\u{1F680}");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path12.join(process.cwd(), "TASKS");
-  const monorepoRoot = path12.dirname(tasksDir);
-  const taskinDir = path12.join(monorepoRoot, ".taskin");
+  const tasksDir = path14.join(process.cwd(), "TASKS");
+  const monorepoRoot = path14.dirname(tasksDir);
+  const taskinDir = path14.join(monorepoRoot, ".taskin");
   const userRegistry = new UserRegistry({ taskinDir });
   await userRegistry.load();
   const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
@@ -13102,6 +13885,232 @@ async function startTask(taskId, _options) {
   }
 }
 
+// src/commands/stats.ts
+init_esm_shims();
+import chalk6 from "chalk";
+import path15 from "path";
+var statsCommand = defineCommand({
+  name: "stats",
+  description: "\u{1F4CA} Show user/team metrics and statistics",
+  options: [
+    {
+      flags: "-u, --user <username>",
+      description: "Show stats for specific user"
+    },
+    {
+      flags: "-p, --period <period>",
+      description: "Time period (day, week, month, year)"
+    },
+    {
+      flags: "-t, --task <taskId>",
+      description: "Show stats for specific task"
+    },
+    {
+      flags: "-d, --detailed",
+      description: "Show detailed metrics"
+    },
+    {
+      flags: "--team",
+      description: "Show team metrics instead of user metrics"
+    }
+  ],
+  handler: async (options) => {
+    await showStats(options);
+  }
+});
+async function showStats(options) {
+  requireTaskinProject();
+  const tasksDir = path15.join(process.cwd(), "TASKS");
+  const userRegistry = new UserRegistry({
+    taskinDir: path15.join(process.cwd(), ".taskin")
+  });
+  await userRegistry.load();
+  const gitAnalyzer = new GitAnalyzer(process.cwd());
+  const metricsAdapter = new FileSystemMetricsAdapter(
+    tasksDir,
+    userRegistry,
+    gitAnalyzer
+  );
+  const query = {
+    period: options.period || "week"
+  };
+  try {
+    if (options.team) {
+      printHeader("Team Statistics", "\u{1F465}");
+      const stats = await metricsAdapter.getTeamMetrics("default", query);
+      displayTeamStats(stats, options.detailed);
+    } else if (options.task) {
+      printHeader(`Task Statistics: ${options.task}`, "\u{1F4CB}");
+      const stats = await metricsAdapter.getTaskMetrics(options.task, query);
+      displayTaskStats(stats, options.detailed);
+    } else {
+      const username = options.user || process.env.USER || "unknown";
+      printHeader(`User Statistics: ${username}`, "\u{1F464}");
+      const stats = await metricsAdapter.getUserMetrics(username, query);
+      displayUserStats(stats, options.detailed);
+    }
+  } catch (error2) {
+    console.error(chalk6.red("\n\u274C Error fetching stats:"), error2);
+    process.exit(1);
+  }
+}
+function displayUserStats(stats, detailed = false) {
+  console.log(
+    `${chalk6.dim("Period:")} ${stats.period} (${formatDate(stats.periodStart)} to ${formatDate(stats.periodEnd)})
+`
+  );
+  console.log(chalk6.bold("\u{1F4DD} Code Metrics"));
+  console.log(
+    `  ${chalk6.green("+")}${stats.codeMetrics.linesAdded} lines added`
+  );
+  console.log(
+    `  ${chalk6.red("-")}${stats.codeMetrics.linesRemoved} lines removed`
+  );
+  console.log(`  ${chalk6.cyan("=")}${stats.codeMetrics.netChange} net change`);
+  console.log(`  \u{1F4C1} ${stats.codeMetrics.filesChanged} files changed`);
+  console.log(`  \u{1F4BE} ${stats.codeMetrics.commits} commits
+`);
+  console.log(chalk6.bold("\u{1F3AF} Contribution"));
+  console.log(
+    `  \u2705 ${stats.contributionMetrics.tasksCompleted} tasks completed`
+  );
+  console.log(
+    `  \u{1F4CA} ${stats.contributionMetrics.activityFrequency.toFixed(2)} commits/day
+`
+  );
+  console.log(chalk6.bold("\u26A1 Engagement"));
+  console.log(
+    `  \u{1F525} ${(stats.engagementMetrics.completionRate * 100).toFixed(1)}% completion rate`
+  );
+  console.log(
+    `  \u{1F4C8} ${stats.engagementMetrics.activeTasksCount} active tasks
+`
+  );
+  if (detailed) {
+    console.log(chalk6.bold("\u23F0 Temporal Patterns"));
+    console.log("  By Day of Week:");
+    const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    Object.entries(stats.temporalMetrics.byDayOfWeek).forEach(
+      ([day, count]) => {
+        const dayName = days[parseInt(day)];
+        const bar = createBar(
+          count,
+          Math.max(...Object.values(stats.temporalMetrics.byDayOfWeek))
+        );
+        console.log(`    ${dayName}: ${bar} ${count}`);
+      }
+    );
+    console.log("\n  By Time of Day:");
+    Object.entries(stats.temporalMetrics.byTimeOfDay).forEach(
+      ([time, count]) => {
+        const maxTime = Math.max(
+          ...Object.values(stats.temporalMetrics.byTimeOfDay)
+        );
+        const bar = createBar(count, maxTime);
+        console.log(`    ${time.padEnd(10)}: ${bar} ${count}`);
+      }
+    );
+    console.log(`
+  \u{1F525} Streak: ${stats.temporalMetrics.streak} days`);
+    console.log(
+      `  \u{1F4C8} Trend: ${getTrendEmoji(stats.temporalMetrics.trend)} ${stats.temporalMetrics.trend}
+`
+    );
+  }
+}
+function displayTeamStats(stats, detailed = false) {
+  console.log(
+    `${chalk6.dim("Period:")} ${stats.period} (${formatDate(stats.periodStart)} to ${formatDate(stats.periodEnd)})
+`
+  );
+  console.log(chalk6.bold("\u{1F465} Team Overview"));
+  console.log(`  \u{1F464} ${stats.totalContributors} contributors`);
+  console.log(`  \u{1F4BE} ${stats.totalCommits} total commits`);
+  console.log(`  \u2705 ${stats.totalTasksCompleted} tasks completed
+`);
+  console.log(chalk6.bold("\u{1F4DD} Code Metrics"));
+  console.log(
+    `  ${chalk6.green("+")}${stats.codeMetrics.linesAdded} lines added`
+  );
+  console.log(
+    `  ${chalk6.red("-")}${stats.codeMetrics.linesRemoved} lines removed`
+  );
+  console.log(`  \u{1F4C1} ${stats.codeMetrics.filesChanged} files changed
+`);
+  if (detailed && stats.contributors.length > 0) {
+    console.log(chalk6.bold("\u{1F3C6} Top Contributors"));
+    stats.contributors.sort((a, b) => {
+      if (b.commits !== a.commits) {
+        return b.commits - a.commits;
+      }
+      if (b.tasksCompleted !== a.tasksCompleted) {
+        return b.tasksCompleted - a.tasksCompleted;
+      }
+      return a.username.localeCompare(b.username);
+    }).slice(0, 5).forEach((contrib, idx) => {
+      console.log(
+        `  ${idx + 1}. ${contrib.username}: ${contrib.commits} commits, ${contrib.tasksCompleted} tasks`
+      );
+    });
+  }
+}
+function displayTaskStats(stats, detailed = false) {
+  console.log(`${chalk6.dim("Task:")} ${stats.taskId} - ${stats.title}
+`);
+  console.log(chalk6.bold("\u{1F4CB} Task Info"));
+  console.log(`  Status: ${getStatusEmoji(stats.status)} ${stats.status}`);
+  console.log(`  Type: ${stats.type}`);
+  console.log(`  Assignee: ${stats.assignee || "unassigned"}
+`);
+  console.log(chalk6.bold("\u{1F4DD} Code Metrics"));
+  console.log(
+    `  ${chalk6.green("+")}${stats.codeMetrics.linesAdded} lines added`
+  );
+  console.log(
+    `  ${chalk6.red("-")}${stats.codeMetrics.linesRemoved} lines removed`
+  );
+  console.log(`  \u{1F4C1} ${stats.codeMetrics.filesChanged} files changed
+`);
+  if (stats.contributors.length > 0) {
+    console.log(chalk6.bold("\u{1F465} Contributors"));
+    stats.contributors.forEach((c) => {
+      console.log(`  \u2022 ${c}`);
+    });
+  }
+}
+function formatDate(isoString) {
+  return new Date(isoString).toLocaleDateString();
+}
+function createBar(value, max, length = 20) {
+  if (max === 0) return "\u2591".repeat(length);
+  const filled = Math.round(value / max * length);
+  return chalk6.cyan("\u2588".repeat(filled)) + chalk6.dim("\u2591".repeat(length - filled));
+}
+function getTrendEmoji(trend) {
+  switch (trend) {
+    case "increasing":
+      return "\u{1F4C8}";
+    case "decreasing":
+      return "\u{1F4C9}";
+    default:
+      return "\u27A1\uFE0F";
+  }
+}
+function getStatusEmoji(status) {
+  switch (status) {
+    case "done":
+      return "\u2705";
+    case "in-progress":
+      return "\u{1F504}";
+    case "blocked":
+      return "\u{1F6AB}";
+    case "pending":
+      return "\u23F3";
+    default:
+      return "\u2753";
+  }
+}
+
 // src/lib/help.ts
 init_esm_shims();
 function showCustomHelp() {
@@ -13264,7 +14273,7 @@ init_esm_shims();
 
 // src/lib/file-system-task-linter/file-system-task-linter.ts
 init_esm_shims();
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import { readdir, readFile as readFile2 } from "fs/promises";
 import { join as join4 } from "path";
 var VALID_STATUSES = ["pending", "in-progress", "done", "blocked"];
@@ -13438,13 +14447,13 @@ var FileSystemTaskLinter = class {
   static printResults(result) {
     if (result.errors.length === 0 && result.warnings.length === 0) {
       console.log(
-        chalk6.green(`\u2705 All ${result.filesChecked} task files are valid!
+        chalk7.green(`\u2705 All ${result.filesChecked} task files are valid!
 `)
       );
       return;
     }
     console.log(
-      chalk6.bold(
+      chalk7.bold(
         `
 \u{1F4CA} Validation Results (${result.filesChecked} files checked):
 `
@@ -13458,19 +14467,19 @@ var FileSystemTaskLinter = class {
       errorsByFile.get(error2.file).push(error2);
     });
     for (const [file, fileErrors] of errorsByFile) {
-      console.log(chalk6.cyan(`
+      console.log(chalk7.cyan(`
 \u{1F4C4} ${file}`));
       for (const error2 of fileErrors) {
-        const icon = error2.severity === "error" ? chalk6.red("\u274C") : chalk6.yellow("\u26A0\uFE0F");
+        const icon = error2.severity === "error" ? chalk7.red("\u274C") : chalk7.yellow("\u26A0\uFE0F");
         const location = error2.line ? `:${error2.line}` : "";
         console.log(`  ${icon} ${error2.message}${location}`);
       }
     }
     console.log("\n" + "\u2500".repeat(60));
     console.log(
-      chalk6.bold(
+      chalk7.bold(
         `
-\u{1F4CA} Summary: ${chalk6.red(result.errors.length + " error(s)")}, ${chalk6.yellow(result.warnings.length + " warning(s)")}
+\u{1F4CA} Summary: ${chalk7.red(result.errors.length + " error(s)")}, ${chalk7.yellow(result.warnings.length + " warning(s)")}
 `
       )
     );
@@ -13644,6 +14653,8 @@ createCommand(program);
 startCommand(program);
 pauseCommand(program);
 finishCommand(program);
+statsCommand(program);
+registerExportCommand(program);
 lintCommand(program);
 dashboardCommand(program);
 mcpServerCommand(program);