@jvittechs/j 1.0.57 → 1.0.59

package/dist/{chunk-FZBVI5AX.js → chunk-SDYQQ4ZY.js}

@@ -1,11 +1,15 @@
+import {
+  SettingsService
+} from "./chunk-BMDRQFY7.js";
+
 // src/commands/tasks/summary.ts
 import { Command } from "commander";
 import chalk2 from "chalk";
 import boxen from "boxen";
 
 // src/services/task.service.ts
-import { promises as fs, existsSync } from "fs";
-import { join, dirname } from "path";
+import { promises as fs2, existsSync } from "fs";
+import { join as join2, dirname } from "path";
 import { execSync } from "child_process";
 import chalk from "chalk";
 
@@ -13,6 +17,7 @@ import chalk from "chalk";
 import { z } from "zod";
 var TaskSchema = z.object({
   id: z.string().regex(/^T-\d+$/),
+  type: z.enum(["feature", "bug", "plan", "task", "prd", "prompt"]).default("task"),
   parent: z.string().default(""),
   title: z.string().min(1).max(500),
   status: z.enum(["todo", "in_progress", "done", "cancelled"]),
@@ -46,20 +51,427 @@ var PRIORITY_LABELS = {
   3: "Low"
 };
 
+// src/services/config.service.ts
+import { promises as fs } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var ConfigService = class {
+  configDir;
+  configPath;
+  constructor() {
+    this.configDir = join(homedir(), ".jai1");
+    this.configPath = join(this.configDir, "config.json");
+  }
+  /**
+   * Check if config file exists
+   */
+  async exists() {
+    try {
+      await fs.access(this.configPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Load configuration from file
+   * @returns Config object or null if not found
+   */
+  async load() {
+    if (!await this.exists()) {
+      return null;
+    }
+    try {
+      const content = await fs.readFile(this.configPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(
+        `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Save configuration to file
+   * Creates directory if it doesn't exist
+   * Sets proper file permissions (600)
+   */
+  async save(config) {
+    try {
+      await fs.mkdir(this.configDir, { recursive: true, mode: 448 });
+      await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), {
+        mode: 384
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to save config: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get config file path
+   */
+  getConfigPath() {
+    return this.configPath;
+  }
+  /**
+   * Get config directory path
+   */
+  getConfigDir() {
+    return this.configDir;
+  }
+};
+
+// src/services/cloud-task-provider.ts
+function mapCloudToLocal(ct) {
+  return {
+    id: ct.task_id,
+    type: ct.type,
+    parent: ct.parent || "",
+    title: ct.title,
+    status: ct.status,
+    assigned_to: ct.assigned_to || "",
+    claimed_at: ct.claimed_at || "",
+    priority: ct.priority ?? 2,
+    depends_on: Array.isArray(ct.depends_on) ? ct.depends_on : parseJsonArray(ct.depends_on),
+    tags: Array.isArray(ct.tags) ? ct.tags : parseJsonArray(ct.tags),
+    branch: ct.branch || "",
+    notes: ct.notes || "",
+    created: ct.created_at?.split("T")[0] || ct.created_at || "",
+    updated: ct.updated_at?.split("T")[0] || ct.updated_at || ""
+  };
+}
+function parseJsonArray(val) {
+  if (Array.isArray(val)) return val;
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function mapLocalToCloud(task) {
+  return {
+    task_id: task.id,
+    title: task.title,
+    type: task.type || "task",
+    parent: task.parent || "",
+    status: task.status,
+    assigned_to: task.assigned_to || "",
+    claimed_at: task.claimed_at || "",
+    priority: task.priority ?? 2,
+    depends_on: task.depends_on || [],
+    tags: task.tags || [],
+    branch: task.branch || "",
+    notes: task.notes || ""
+  };
+}
+var CloudTaskProvider = class {
+  apiUrl;
+  accessKey;
+  projectId;
+  constructor(config, projectId) {
+    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    this.accessKey = config.accessKey;
+    this.projectId = projectId;
+  }
+  // ============================================
+  // HELPERS
+  // ============================================
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      "JAI1-Access-Key": this.accessKey
+    };
+  }
+  async request(path, options = {}) {
+    const url = `${this.apiUrl}${path}`;
+    const res = await fetch(url, {
+      ...options,
+      headers: { ...this.headers(), ...options.headers || {} }
+    });
+    if (!res.ok) {
+      let errMsg = `API error ${res.status}`;
+      try {
+        const body = await res.json();
+        if (body.error) errMsg = body.error;
+      } catch {
+      }
+      throw new Error(errMsg);
+    }
+    const data = await res.json();
+    if (!data.success) throw new Error(data.error || "API returned failure");
+    return data.data;
+  }
+  // ============================================
+  // ENSURE PROJECT REGISTERED
+  // ============================================
+  async ensureProjectRegistered(repoUrl) {
+    const result = await this.request(
+      "/api/projects/register",
+      {
+        method: "POST",
+        body: JSON.stringify({ repo_url: repoUrl })
+      }
+    );
+    return result.project_id;
+  }
+  // ============================================
+  // CRUD
+  // ============================================
+  async readAll() {
+    const rows = await this.request(
+      `/api/tasks?projectId=${encodeURIComponent(this.projectId)}`
+    );
+    return rows.map(mapCloudToLocal);
+  }
+  async add(input) {
+    const all = await this.readAll().catch(() => []);
+    const maxNum = all.reduce((max, t) => {
+      const n = parseInt(t.id.replace("T-", ""), 10);
+      return isNaN(n) ? max : Math.max(max, n);
+    }, 0);
+    const taskId = `T-${String(maxNum + 1).padStart(3, "0")}`;
+    const row = await this.request("/api/tasks", {
+      method: "POST",
+      body: JSON.stringify({
+        task_id: taskId,
+        project_id: this.projectId,
+        title: input.title,
+        type: input.type || "task",
+        parent: input.parent || "",
+        priority: input.priority ?? 2,
+        depends_on: input.depends_on || [],
+        tags: input.tags || [],
+        branch: input.branch || "",
+        notes: input.notes || ""
+      })
+    });
+    return mapCloudToLocal(row);
+  }
+  async update(id, updates) {
+    const row = await this.request(
+      `/api/tasks/${encodeURIComponent(id)}?projectId=${encodeURIComponent(this.projectId)}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(updates)
+      }
+    );
+    return mapCloudToLocal(row);
+  }
+  async deleteTask(id) {
+    await this.request(
+      `/api/tasks/${encodeURIComponent(id)}?projectId=${encodeURIComponent(this.projectId)}`,
+      { method: "DELETE" }
+    );
+  }
+  async deleteGroup(parent) {
+    await this.request(
+      `/api/tasks/group/${encodeURIComponent(parent)}?projectId=${encodeURIComponent(this.projectId)}`,
+      { method: "DELETE" }
+    );
+  }
+  // ============================================
+  // QUERY
+  // ============================================
+  async list(options) {
+    const params = new URLSearchParams({ projectId: this.projectId });
+    if (options?.status) params.set("status", options.status);
+    if (options?.type) params.set("type", options.type);
+    if (options?.parent !== void 0) params.set("parent", options.parent);
+    const rows = await this.request(`/api/tasks?${params}`);
+    return rows.map(mapCloudToLocal);
+  }
+  async getById(id) {
+    try {
+      const row = await this.request(
+        `/api/tasks/${encodeURIComponent(id)}?projectId=${encodeURIComponent(this.projectId)}`
+      );
+      return mapCloudToLocal(row);
+    } catch {
+      return null;
+    }
+  }
+  async getParents() {
+    const parents = await this.request(
+      `/api/tasks/parents?projectId=${encodeURIComponent(this.projectId)}`
+    );
+    const result = [];
+    for (const parent of parents) {
+      const tasks = await this.list({ parent });
+      const info = {
+        name: parent,
+        total: tasks.length,
+        todo: tasks.filter((t) => t.status === "todo").length,
+        in_progress: tasks.filter((t) => t.status === "in_progress").length,
+        done: tasks.filter((t) => t.status === "done").length,
+        cancelled: tasks.filter((t) => t.status === "cancelled").length,
+        blocked: 0,
+        ready: 0,
+        status: "todo"
+      };
+      if (info.done + info.cancelled === info.total) info.status = "done";
+      else if (info.in_progress > 0) info.status = "in_progress";
+      else if (info.todo > 0) info.status = "ready";
+      result.push(info);
+    }
+    return result;
+  }
+  async getStats() {
+    const raw = await this.request(
+      `/api/tasks/stats?projectId=${encodeURIComponent(this.projectId)}`
+    );
+    const s = raw.by_status;
+    const total = Object.values(s).reduce((a, b) => a + b, 0);
+    return {
+      total,
+      todo: s["todo"] || 0,
+      in_progress: s["in_progress"] || 0,
+      done: s["done"] || 0,
+      cancelled: s["cancelled"] || 0
+    };
+  }
+  // ============================================
+  // WORKFLOW
+  // ============================================
+  async getReady() {
+    const rows = await this.request(
+      `/api/tasks/ready?projectId=${encodeURIComponent(this.projectId)}`
+    );
+    return rows.map(mapCloudToLocal);
+  }
+  async pick(id, agentId) {
+    const row = await this.request(
+      `/api/tasks/${encodeURIComponent(id)}/pick`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          project_id: this.projectId,
+          agent_id: agentId || "cli"
+        })
+      }
+    );
+    return mapCloudToLocal(row);
+  }
+  async markDone(id) {
+    const row = await this.request(
+      `/api/tasks/${encodeURIComponent(id)}/done`,
+      {
+        method: "POST",
+        body: JSON.stringify({ project_id: this.projectId })
+      }
+    );
+    return mapCloudToLocal(row);
+  }
+  async cancel(id) {
+    await this.request(`/api/tasks/${encodeURIComponent(id)}/cancel`, {
+      method: "POST",
+      body: JSON.stringify({ project_id: this.projectId })
+    });
+    const task = await this.getById(id);
+    return task;
+  }
+  // ============================================
+  // SYNC
+  // ============================================
+  async pull() {
+    return this.readAll();
+  }
+  async push(tasks) {
+    for (const task of tasks) {
+      const cloudFields = mapLocalToCloud(task);
+      try {
+        await this.request(
+          `/api/tasks/${encodeURIComponent(task.id)}?projectId=${encodeURIComponent(this.projectId)}`,
+          { method: "PATCH", body: JSON.stringify(cloudFields) }
+        );
+      } catch {
+        try {
+          await this.request("/api/tasks", {
+            method: "POST",
+            body: JSON.stringify({
+              ...cloudFields,
+              project_id: this.projectId
+            })
+          });
+        } catch {
+        }
+      }
+    }
+  }
+};
+
 // src/services/task.service.ts
 var TASKS_FILE = ".jai1/tasks.jsonl";
 var SYNC_BRANCH = "jai1";
 var TaskService = class {
   tasksPath;
+  cwd;
+  _cloudProvider = null;
+  _providerReady;
   constructor(cwd) {
-    this.tasksPath = join(cwd || process.cwd(), TASKS_FILE);
+    this.cwd = cwd || process.cwd();
+    this.tasksPath = join2(this.cwd, TASKS_FILE);
+    this._providerReady = this._initCloudProvider();
+  }
+  /**
+   * Initialise cloud provider if settings.yaml has tasks.cloud = true.
+   * Auto-registers the project on the server on first use.
+   */
+  async _initCloudProvider() {
+    try {
+      const settings = new SettingsService(this.cwd);
+      if (!settings.isTaskCloudEnabled()) return;
+      const config = await new ConfigService().load();
+      if (!config?.apiUrl || !config?.accessKey) return;
+      const repoUrl = settings.resolveGitRepoUrl();
+      if (!repoUrl) return;
+      let projectId = settings.getProjectId();
+      if (!projectId) return;
+      const provider = new CloudTaskProvider(config, projectId);
+      try {
+        const registeredId = await provider.ensureProjectRegistered(repoUrl);
+        if (registeredId && registeredId !== projectId) {
+          projectId = registeredId;
+          await settings.set("tasks.projectId", registeredId);
+          this._cloudProvider = new CloudTaskProvider(config, registeredId);
+          return;
+        }
+      } catch {
+      }
+      this._cloudProvider = provider;
+    } catch {
+    }
+  }
+  /**
+   * Wait for provider initialisation (call before any cloud operation)
+   */
+  async waitForInit() {
+    await this._providerReady;
+  }
+  /** @internal alias kept for backward compat */
+  async ready() {
+    await this._providerReady;
+  }
+  /**
+   * Returns true when cloud mode is active
+   */
+  get isCloud() {
+    return this._cloudProvider !== null;
+  }
+  /**
+   * Returns cloud provider if active
+   */
+  get cloud() {
+    return this._cloudProvider;
   }
   /**
    * Check if .jai1 directory exists in CWD.
    * If not, print a helpful message and exit.
    */
   static ensureJai1Dir(cwd) {
-    const dir = join(cwd || process.cwd(), ".jai1");
+    const dir = join2(cwd || process.cwd(), ".jai1");
     if (!existsSync(dir)) {
       console.error(chalk.red("\u274C Th\u01B0 m\u1EE5c .jai1 kh\xF4ng t\u1ED3n t\u1EA1i trong project n\xE0y."));
       console.error("");
@@ -76,12 +488,16 @@ var TaskService = class {
   // READ
   // ============================================
   /**
-   * Read all tasks from JSONL file
+   * Read all tasks from JSONL file (or cloud API if cloud mode)
    */
   async readAll() {
+    await this.ready();
+    if (this._cloudProvider) {
+      return this._cloudProvider.readAll();
+    }
     try {
       await this.ensureTasksFileNotDirectory();
-      const content = await fs.readFile(this.tasksPath, "utf-8");
+      const content = await fs2.readFile(this.tasksPath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
       return lines.map((line) => TaskSchema.parse(JSON.parse(line)));
     } catch (error) {
@@ -95,6 +511,10 @@ var TaskService = class {
    * Find task by ID
    */
   async findById(id) {
+    await this.ready();
+    if (this._cloudProvider) {
+      return this._cloudProvider.getById(id);
+    }
     const tasks = await this.readAll();
     return tasks.find((t) => t.id === id) || null;
   }
@@ -102,6 +522,17 @@ var TaskService = class {
    * Filter tasks by criteria
    */
   async filter(criteria) {
+    await this.ready();
+    if (this._cloudProvider) {
+      const listInput = {};
+      if (criteria.status) listInput.status = criteria.status;
+      if (criteria.parent) listInput.parent = criteria.parent;
+      const tasks2 = await this._cloudProvider.list(listInput);
+      if (criteria.assignee) {
+        return tasks2.filter((t) => t.assigned_to === criteria.assignee);
+      }
+      return tasks2;
+    }
     const tasks = await this.readAll();
     return tasks.filter((t) => {
       if (criteria.status && t.status !== criteria.status) return false;
@@ -115,6 +546,12 @@ var TaskService = class {
    * status=todo, all depends_on done or cancelled, assigned_to empty
    */
   async getReady(parent) {
+    await this.ready();
+    if (this._cloudProvider) {
+      const ready = await this._cloudProvider.getReady();
+      if (parent) return ready.filter((t) => t.parent === parent);
+      return ready;
+    }
     const tasks = await this.readAll();
     const resolvedIds = new Set(
       tasks.filter((t) => t.status === "done" || t.status === "cancelled").map((t) => t.id)
@@ -147,6 +584,11 @@ var TaskService = class {
    * Get stats by status
    */
   async getStats() {
+    await this.ready();
+    if (this._cloudProvider) {
+      const stats = await this._cloudProvider.getStats();
+      return { ...stats, blocked: 0 };
+    }
     const tasks = await this.readAll();
     const resolvedIds = new Set(
       tasks.filter((t) => t.status === "done" || t.status === "cancelled").map((t) => t.id)
@@ -176,6 +618,12 @@ var TaskService = class {
    *   todo         = otherwise (blocked or waiting)
    */
   async getParents(statusFilter) {
+    await this.ready();
+    if (this._cloudProvider) {
+      const parents2 = await this._cloudProvider.getParents();
+      if (statusFilter) return parents2.filter((p) => p.status === statusFilter);
+      return parents2;
+    }
     const tasks = await this.readAll();
     const resolvedIds = new Set(
       tasks.filter((t) => t.status === "done" || t.status === "cancelled").map((t) => t.id)
@@ -252,10 +700,24 @@ var TaskService = class {
    * Add a new task
    */
   async add(data) {
+    await this.ready();
+    if (this._cloudProvider) {
+      const input = {
+        title: data.title,
+        ...data.type !== void 0 && { type: data.type },
+        ...data.parent !== void 0 && { parent: data.parent },
+        ...data.priority !== void 0 && { priority: data.priority },
+        ...data.tags !== void 0 && { tags: data.tags },
+        ...data.notes !== void 0 && { notes: data.notes },
+        ...data.branch !== void 0 && { branch: data.branch }
+      };
+      return this._cloudProvider.add(input);
+    }
     const id = await this.nextId();
     const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const task = TaskSchema.parse({
       id,
+      type: data.type || "task",
       parent: data.parent || "",
       title: data.title,
       status: "todo",
@@ -266,8 +728,8 @@ var TaskService = class {
       created: now,
       updated: now,
       tags: data.tags || [],
-      branch: "",
-      notes: ""
+      branch: data.branch || "",
+      notes: data.notes || ""
     });
     await this.appendTask(task);
     return task;
@@ -276,6 +738,10 @@ var TaskService = class {
    * Update a task by ID
    */
   async update(id, changes) {
+    await this.ready();
+    if (this._cloudProvider) {
+      return this._cloudProvider.update(id, changes);
+    }
     const tasks = await this.readAll();
     const index = tasks.findIndex((t) => t.id === id);
     if (index === -1) {
@@ -291,6 +757,7 @@ var TaskService = class {
    * Add dependency: child depends on parent
    */
   async addDependency(childId, parentId) {
+    await this.ready();
     const tasks = await this.readAll();
     const child = tasks.find((t) => t.id === childId);
     const parent = tasks.find((t) => t.id === parentId);
@@ -311,6 +778,10 @@ var TaskService = class {
    * Mark task as done
    */
   async markDone(id) {
+    await this.ready();
+    if (this._cloudProvider) {
+      return this._cloudProvider.markDone(id);
+    }
     return this.update(id, { status: "done" });
   }
   /**
@@ -324,6 +795,10 @@ var TaskService = class {
    * Cancel a task: set status=cancelled, clear assignment
    */
   async cancel(id) {
+    await this.ready();
+    if (this._cloudProvider) {
+      return this._cloudProvider.cancel(id);
+    }
     return this.update(id, {
       status: "cancelled",
       assigned_to: "",
@@ -334,6 +809,10 @@ var TaskService = class {
    * Delete a task completely and clean up depends_on references
    */
   async deleteTask(id) {
+    await this.ready();
+    if (this._cloudProvider) {
+      return this._cloudProvider.deleteTask(id);
+    }
     return this.deleteTasks([id]);
   }
   /**
@@ -341,6 +820,13 @@ var TaskService = class {
    * Validates all IDs exist before deleting any.
    */
   async deleteTasks(ids) {
+    await this.ready();
+    if (this._cloudProvider) {
+      for (const id of ids) {
+        await this._cloudProvider.deleteTask(id);
+      }
+      return;
+    }
     const tasks = await this.readAll();
     const deleteSet = new Set(ids);
     const notFound = ids.filter((id) => !tasks.find((t) => t.id === id));
@@ -363,6 +849,15 @@ var TaskService = class {
    * Returns the list of deleted tasks for display purposes.
    */
   async deleteGroup(parentName) {
+    await this.ready();
+    if (this._cloudProvider) {
+      const groupTasks2 = await this._cloudProvider.list({ parent: parentName });
+      if (groupTasks2.length === 0) {
+        throw new Error(`No tasks found in group: ${parentName}`);
+      }
+      await this._cloudProvider.deleteGroup(parentName);
+      return groupTasks2;
+    }
     const tasks = await this.readAll();
     const groupTasks = tasks.filter((t) => t.parent === parentName);
     if (groupTasks.length === 0) {
@@ -376,6 +871,10 @@ var TaskService = class {
    * Pick next task: claim for current user
    */
   async pick(taskId) {
+    await this.ready();
+    if (this._cloudProvider) {
+      return this._cloudProvider.pick(taskId, this.getCurrentUser());
+    }
     const username = this.getCurrentUser();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     return this.update(taskId, {
@@ -469,9 +968,9 @@ var TaskService = class {
    * - Dirty working tree → stash/unstash automatically
    */
   async syncPush() {
-    const cwd = process.cwd();
+    const cwd = this.cwd;
     const branch = SYNC_BRANCH;
-    const tasksFullPath = join(cwd, TASKS_FILE);
+    const tasksFullPath = join2(cwd, TASKS_FILE);
     if (!existsSync(tasksFullPath)) {
       return;
     }
@@ -535,7 +1034,7 @@ var TaskService = class {
    * - tasks.jsonl doesn't exist on remote branch → returns empty
    */
   async syncPull() {
-    const cwd = process.cwd();
+    const cwd = this.cwd;
     const branch = SYNC_BRANCH;
     let merged = 0;
     let conflicts = 0;
@@ -581,16 +1080,16 @@ var TaskService = class {
   async appendTask(task) {
     await this.ensureTasksFileNotDirectory();
     const dir = dirname(this.tasksPath);
-    await fs.mkdir(dir, { recursive: true });
+    await fs2.mkdir(dir, { recursive: true });
     const line = JSON.stringify(task) + "\n";
-    await fs.appendFile(this.tasksPath, line, "utf-8");
+    await fs2.appendFile(this.tasksPath, line, "utf-8");
   }
   async writeAll(tasks) {
     await this.ensureTasksFileNotDirectory();
     const dir = dirname(this.tasksPath);
-    await fs.mkdir(dir, { recursive: true });
+    await fs2.mkdir(dir, { recursive: true });
     const content = tasks.map((t) => JSON.stringify(t)).join("\n") + "\n";
-    await fs.writeFile(this.tasksPath, content, "utf-8");
+    await fs2.writeFile(this.tasksPath, content, "utf-8");
   }
   getCurrentUser() {
     try {
@@ -618,7 +1117,7 @@ var TaskService = class {
   }
   async ensureTasksFileNotDirectory() {
     try {
-      const stat = await fs.stat(this.tasksPath);
+      const stat = await fs2.stat(this.tasksPath);
       if (stat.isDirectory()) {
         throw new Error(
           `Invalid tasks path: expected file at ${TASKS_FILE} but found a directory. Please remove the directory and re-run the command.`
@@ -685,6 +1184,7 @@ function createTaskSummaryCommand() {
 }
 
 export {
+  ConfigService,
   STATUS_ICONS,
   BLOCKED_ICON,
   PRIORITY_ICONS,
@@ -693,4 +1193,4 @@ export {
   handleTaskSummary,
   createTaskSummaryCommand
 };
-//# sourceMappingURL=chunk-FZBVI5AX.js.map
+//# sourceMappingURL=chunk-SDYQQ4ZY.js.map