jioogen 0.2.1 → 0.2.2

package/dist/index.js

@@ -363,9 +363,9 @@ var require_utils = __commonJS({
         fpath.split(self.sep).forEach(function(name) {
           if (!name || name.substr(-1, 1) === ":") return;
           resolvedPath += self.sep + name;
-          var stat;
+          var stat2;
           try {
-            stat = self.fs.statSync(resolvedPath);
+            stat2 = self.fs.statSync(resolvedPath);
           } catch (e) {
             if (e.message && e.message.startsWith("ENOENT")) {
               self.fs.mkdirSync(resolvedPath);
@@ -373,7 +373,7 @@ var require_utils = __commonJS({
               throw e;
             }
           }
-          if (stat && stat.isFile()) throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
+          if (stat2 && stat2.isFile()) throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
         });
       }
       mkdirSync(folder);
@@ -382,8 +382,8 @@ var require_utils = __commonJS({
       const self = this;
       if (self.fs.existsSync(path)) {
         if (!overwrite) return false;
-        var stat = self.fs.statSync(path);
-        if (stat.isDirectory()) {
+        var stat2 = self.fs.statSync(path);
+        if (stat2.isDirectory()) {
           return false;
         }
       }
@@ -416,8 +416,8 @@ var require_utils = __commonJS({
       const self = this;
       self.fs.exists(path, function(exist) {
         if (exist && !overwrite) return callback(false);
-        self.fs.stat(path, function(err, stat) {
-          if (exist && stat && stat.isDirectory()) {
+        self.fs.stat(path, function(err, stat2) {
+          if (exist && stat2 && stat2.isDirectory()) {
             return callback(false);
           }
           var folder = pth.dirname(path);
@@ -469,13 +469,13 @@ var require_utils = __commonJS({
       for (const part of rel.split(pth.sep)) {
         if (!part || part === ".") continue;
         cur = pth.join(cur, part);
-        let stat;
+        let stat2;
         try {
-          stat = self.fs.lstatSync(cur);
+          stat2 = self.fs.lstatSync(cur);
         } catch (e) {
           break;
         }
-        if (stat.isSymbolicLink()) throw Errors.FILE_IN_THE_WAY(`"${cur}"`);
+        if (stat2.isSymbolicLink()) throw Errors.FILE_IN_THE_WAY(`"${cur}"`);
       }
     };
     Utils.prototype.findFiles = function(path) {
@@ -502,11 +502,11 @@ var require_utils = __commonJS({
         self.fs.readdirSync(dir).forEach(function(file) {
           const path2 = pth.join(dir, file);
           if (escapesRoot(path2)) return;
-          const stat = self.fs.statSync(path2);
+          const stat2 = self.fs.statSync(path2);
           if (!pattern || pattern.test(path2)) {
-            files.push(pth.normalize(path2) + (stat.isDirectory() ? self.sep : ""));
+            files.push(pth.normalize(path2) + (stat2.isDirectory() ? self.sep : ""));
           }
-          if (stat.isDirectory() && recursive) {
+          if (stat2.isDirectory() && recursive) {
             const realDir = self.fs.realpathSync(path2);
             if (!visited.has(realDir)) {
               visited.add(realDir);
@@ -553,14 +553,14 @@ var require_utils = __commonJS({
                 if (!--pending) done();
                 return;
               }
-              self.fs.stat(file, function(err3, stat) {
+              self.fs.stat(file, function(err3, stat2) {
                 if (err3) return done(err3);
-                if (!stat) {
+                if (!stat2) {
                   if (!--pending) done();
                   return;
                 }
-                results.push(pth.normalize(file) + (stat.isDirectory() ? self.sep : ""));
-                if (!stat.isDirectory()) {
+                results.push(pth.normalize(file) + (stat2.isDirectory() ? self.sep : ""));
+                if (!stat2.isDirectory()) {
                   if (!--pending) done();
                   return;
                 }
@@ -8433,8 +8433,11 @@ function envValue(name) {
   const value = process.env[name]?.trim();
   return value !== void 0 && value.length > 0 ? value : void 0;
 }
+function configDirOverride() {
+  return envValue(CONFIG_DIR_ENV) ?? envValue(LEGACY_CONFIG_DIR_ENV);
+}
 function configDir() {
-  const override = envValue(CONFIG_DIR_ENV) ?? envValue(LEGACY_CONFIG_DIR_ENV);
+  const override = configDirOverride();
   return override !== void 0 ? resolve(override) : join2(homedir(), ".config", "jioogen");
 }
 function legacyConfigDir() {
@@ -8474,6 +8477,7 @@ async function readCredentialsFile(path) {
 async function readCredentials() {
   const primary = await readCredentialsFile(credentialsPath());
   if (primary !== null) return primary;
+  if (configDirOverride() !== void 0) return null;
   const legacyPath = join2(legacyConfigDir(), CREDENTIALS_FILE);
   if (legacyPath === credentialsPath()) return null;
   return readCredentialsFile(legacyPath);
@@ -8558,6 +8562,10 @@ function isMissingFile(error) {
   return isRecord(error) && error.code === "ENOENT";
 }
 
+// src/errors.ts
+var UsageError = class extends Error {
+};
+
 // src/output.ts
 function formatTable(headers, rows) {
   const widths = headers.map(
@@ -8569,11 +8577,52 @@ function formatTable(headers, rows) {
 }
 
 // src/sidecar.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { mkdir as mkdir2, open, readFile as readFile3, rename, rm as rm2, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join3 } from "node:path";
+var LOCK_RETRY_MS = 25;
+var LOCK_TIMEOUT_MS = 3e3;
+var LOCK_STALE_MS = 1e4;
 function sidecarPath(bundleDir) {
   return join3(bundleDir, EXECUTION_SIDECAR_PATH);
 }
+function lockPath(bundleDir) {
+  return `${sidecarPath(bundleDir)}.lock`;
+}
+async function withStateLock(bundleDir, fn) {
+  const target = lockPath(bundleDir);
+  await mkdir2(dirname2(target), { recursive: true });
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  let handle = null;
+  let staleRemoved = false;
+  while (handle === null) {
+    try {
+      handle = await open(target, "wx");
+    } catch (error) {
+      if (!isLockBusy(error)) throw error;
+      if (!staleRemoved && await removeStaleLock(target)) {
+        staleRemoved = true;
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `Gagal mengambil lock sidecar setelah ${LOCK_TIMEOUT_MS / 1e3} detik: ${target}. Kemungkinan proses lain masih menulis; hapus file lock itu bila proses tersebut sudah mati.`
+        );
+      }
+      await delay(LOCK_RETRY_MS);
+    }
+  }
+  try {
+    await handle.writeFile(`${process.pid}
+`, "utf8");
+    return await fn();
+  } finally {
+    await handle.close().catch(() => {
+    });
+    await rm2(target, { force: true }).catch(() => {
+    });
+  }
+}
 async function readState(bundleDir) {
   let raw;
   try {
@@ -8662,8 +8711,16 @@ async function writeState(bundleDir, state) {
   const normalized = rebuild(state, state.tasks, state.current);
   const target = sidecarPath(bundleDir);
   await mkdir2(dirname2(target), { recursive: true });
-  await writeFile2(target, `${JSON.stringify(normalized, null, 2)}
+  const temp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile2(temp, `${JSON.stringify(normalized, null, 2)}
 `, "utf8");
+    await rename(temp, target);
+  } catch (error) {
+    await rm2(temp, { force: true }).catch(() => {
+    });
+    throw error;
+  }
   return normalized;
 }
 function rebuild(state, tasks, current, now = /* @__PURE__ */ new Date()) {
@@ -8690,6 +8747,23 @@ function toTaskState(task) {
 function isMissingFile2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
+function isLockBusy(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+async function removeStaleLock(target) {
+  try {
+    const info = await stat(target);
+    if (Date.now() - info.mtimeMs < LOCK_STALE_MS) return false;
+    await rm2(target, { force: true });
+    return true;
+  } catch (error) {
+    if (isMissingFile2(error)) return true;
+    throw error;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
 
 // src/skills.ts
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
@@ -9106,6 +9180,10 @@ async function extractBundle(bytes, targetDir) {
 }
 
 // src/commands.ts
+var PROJECT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isValidProjectId(projectId) {
+  return PROJECT_ID_RE.test(projectId.trim());
+}
 async function loginCommand(options) {
   const token = options.token ?? envFirst("JIOOGEN_TOKEN", "JIOOCODE_TOKEN");
   if (token !== void 0 && token.length > 0) {
@@ -9186,9 +9264,14 @@ async function projectsCommand(options) {
   );
 }
 async function pullCommand(projectId, options) {
+  if (!isValidProjectId(projectId)) {
+    throw new UsageError(
+      `Project id tidak valid: ${projectId}. Gunakan UUID dari \`jioogen projects\`.`
+    );
+  }
   const { apiUrl, client } = await resolveApi(options);
   const target = resolve4(options.dir ?? projectId);
-  await assertPullTarget(target, projectId);
+  await assertPullTarget(target, projectId, options.force === true);
   const bytes = await client.getBytes(projectPath(projectId, "/bundle"));
   const written = await extractBundle(bytes, target);
   const skills = await installAgentSkills(target);
@@ -9264,9 +9347,15 @@ async function handoffCommand(options) {
   }
 }
 async function taskNextCommand(options) {
-  const { bundleDir, state, definitions, projectId } = await loadLocalState(options);
-  const written = await writeState(bundleDir, state);
-  const next = selectNext(definitions, written.tasks);
+  const { projectId, definitions, written, next } = await withLocalState(options, async (local) => {
+    const written2 = await writeState(local.bundleDir, local.state);
+    return {
+      projectId: local.projectId,
+      definitions: local.definitions,
+      written: written2,
+      next: selectNext(local.definitions, written2.tasks)
+    };
+  });
   if (next === null) {
     if (options.json === true) {
       console.log(JSON.stringify({ done: true, projectId }, null, 2));
@@ -9315,62 +9404,71 @@ Status: ${next.state.status} \u2014 silakan ulangi.`);
 Progress: ${written.counts?.done ?? 0}/${definitions.length} task selesai.`);
 }
 async function taskStartCommand(ref, options) {
-  const { bundleDir, state } = await loadLocalState(options);
-  const updated = withStatus(state, ref, "in_progress", {
-    awaitingCheckpoint: false,
-    note: ""
+  const task = await withLocalState(options, async (local) => {
+    assertStartDependencies(ref, local.definitions, local.state.tasks);
+    const updated = withStatus(local.state, ref, "in_progress", {
+      awaitingCheckpoint: false,
+      note: ""
+    });
+    await writeState(local.bundleDir, updated);
+    return updated.tasks.find((entry) => entry.ref.toUpperCase() === ref.toUpperCase());
   });
-  await writeState(bundleDir, updated);
-  const task = updated.tasks.find((entry) => entry.ref.toUpperCase() === ref.toUpperCase());
   console.log(`Started ${task?.ref ?? ref} (attempt ${task?.attempt ?? 1}).`);
 }
 async function taskCompleteCommand(ref, options) {
-  const { bundleDir, state, definitions } = await loadLocalState(options);
-  const completed = withStatus(state, ref, "done", {
-    note: options.note ?? "",
-    awaitingCheckpoint: false
-  });
-  const completedTask = completed.tasks.find(
-    (entry) => entry.ref.toUpperCase() === ref.toUpperCase()
-  );
-  const next = selectNext(definitions, completed.tasks);
-  if (completedTask !== void 0 && next !== null && isBoundary(completedTask, next.task)) {
-    const withCheckpoint = setCurrent(completed, {
-      ref: next.task.id,
-      ...next.task.layer !== void 0 ? { layer: next.task.layer } : {},
-      phase: next.task.phase,
-      awaitingCheckpoint: true
+  const { completedTask, next, checkpoint } = await withLocalState(options, async (local) => {
+    assertCompleteDependencies(ref, local.definitions, local.state.tasks, options.force === true);
+    const completed = withStatus(local.state, ref, "done", {
+      note: options.note ?? "",
+      awaitingCheckpoint: false
     });
-    await writeState(bundleDir, withCheckpoint);
-    console.log(`Done ${completedTask.ref}.`);
+    const completedTask2 = completed.tasks.find(
+      (entry) => entry.ref.toUpperCase() === ref.toUpperCase()
+    );
+    const next2 = selectNext(local.definitions, completed.tasks);
+    if (completedTask2 !== void 0 && next2 !== null && isBoundary(completedTask2, next2.task)) {
+      const withCheckpoint = setCurrent(completed, {
+        ref: next2.task.id,
+        ...next2.task.layer !== void 0 ? { layer: next2.task.layer } : {},
+        phase: next2.task.phase,
+        awaitingCheckpoint: true
+      });
+      await writeState(local.bundleDir, withCheckpoint);
+      return { completedTask: completedTask2, next: next2, checkpoint: true };
+    }
+    await writeState(local.bundleDir, completed);
+    return { completedTask: completedTask2, next: next2, checkpoint: false };
+  });
+  console.log(`Done ${completedTask?.ref ?? ref}.`);
+  if (checkpoint && next !== null) {
     console.log(
       `Checkpoint berikutnya: ${next.task.id} (${next.task.layer ?? "-"} / phase ${next.task.phase}).`
     );
     console.log("Berhenti dan minta konfirmasi user sebelum task start berikutnya.");
     return;
   }
-  await writeState(bundleDir, completed);
-  console.log(`Done ${completedTask?.ref ?? ref}.`);
   if (next !== null) console.log(`Berikutnya: ${next.task.id} \u2014 ${next.task.title}`);
 }
 async function taskFailCommand(ref, reasonParts, options) {
   const reason = reasonParts.join(" ").trim() || options.note || "";
-  const { bundleDir, state } = await loadLocalState(options);
-  const updated = withStatus(state, ref, "failed", {
-    note: reason,
-    awaitingCheckpoint: false
+  await withLocalState(options, async (local) => {
+    const updated = withStatus(local.state, ref, "failed", {
+      note: reason,
+      awaitingCheckpoint: false
+    });
+    await writeState(local.bundleDir, updated);
   });
-  await writeState(bundleDir, updated);
   console.log(`Failed ${ref}${reason.length > 0 ? `: ${reason}` : "."}`);
 }
 async function taskResetCommand(ref, reasonParts, options) {
   const reason = reasonParts.join(" ").trim() || options.note || "";
-  const { bundleDir, state } = await loadLocalState(options);
-  const updated = withStatus(state, ref, "todo", {
-    note: reason,
-    awaitingCheckpoint: false
+  await withLocalState(options, async (local) => {
+    const updated = withStatus(local.state, ref, "todo", {
+      note: reason,
+      awaitingCheckpoint: false
+    });
+    await writeState(local.bundleDir, updated);
   });
-  await writeState(bundleDir, updated);
   console.log(`Reset ${ref} ke todo${reason.length > 0 ? `: ${reason}` : "."}`);
 }
 async function statusCommand(options) {
@@ -9381,6 +9479,23 @@ async function statusCommand(options) {
   const { bundleDir, projectId } = await resolveLocalBundle(options);
   const existing = await readState(bundleDir);
   if (existing === null) {
+    if (options.json === true) {
+      console.log(
+        JSON.stringify(
+          {
+            projectId,
+            hasExecution: false,
+            tasks: [],
+            counts: summarizeExecutionCounts([]),
+            current: null,
+            updatedAt: null
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
     console.log(`Project ${projectId}: belum ada sidecar. Jalankan \`jioogen task next\`.`);
     return;
   }
@@ -9487,14 +9602,40 @@ async function resolveBundle(options) {
   const api = await resolveApi({ api: options.api ?? local.linkedApiUrl });
   return { ...api, ...local };
 }
-async function loadLocalState(options) {
+async function withLocalState(options, fn) {
   const context = await resolveLocalBundle(options);
-  const definitions = await loadTasks(context.bundleDir);
-  const existing = await readState(context.bundleDir);
-  const state = existing === null ? createState(context.projectId, definitions) : mergeTasks(existing, definitions);
-  return { ...context, definitions, state };
+  return withStateLock(context.bundleDir, async () => {
+    const definitions = await loadTasks(context.bundleDir);
+    const existing = await readState(context.bundleDir);
+    const state = existing === null ? createState(context.projectId, definitions) : mergeTasks(existing, definitions);
+    return fn({ ...context, definitions, state });
+  });
 }
-async function assertPullTarget(target, projectId) {
+function unmetDependencies(ref, definitions, states) {
+  const key = ref.toUpperCase();
+  const definition = definitions.find((task) => task.id.toUpperCase() === key);
+  if (definition === void 0) return [];
+  const byRef = new Map(states.map((state) => [state.ref.toUpperCase(), state]));
+  return definition.dependsOn.filter(
+    (dependency) => byRef.get(dependency.toUpperCase())?.status !== "done"
+  );
+}
+function assertStartDependencies(ref, definitions, states) {
+  const missing = unmetDependencies(ref, definitions, states);
+  if (missing.length === 0) return;
+  throw new Error(
+    `Tidak bisa memulai ${ref}: dependency belum selesai (${missing.join(", ")}). Selesaikan dependency itu lebih dulu.`
+  );
+}
+function assertCompleteDependencies(ref, definitions, states, force) {
+  if (force) return;
+  const missing = unmetDependencies(ref, definitions, states);
+  if (missing.length === 0) return;
+  throw new Error(
+    `Tidak bisa menyelesaikan ${ref}: dependency belum selesai (${missing.join(", ")}). Selesaikan dependency itu lebih dulu, atau tambahkan --force bila memang disengaja.`
+  );
+}
+async function assertPullTarget(target, projectId, force = false) {
   let entries;
   try {
     entries = await readdir3(target);
@@ -9510,6 +9651,11 @@ async function assertPullTarget(target, projectId) {
   if (link.projectId !== projectId) {
     throw new Error(`Direktori ${target} terikat ke project ${link.projectId}.`);
   }
+  if (!force) {
+    throw new Error(
+      `Direktori ${target} sudah berisi bundle project ini; pull ulang akan menimpa edit lokal. Jalankan \`jioogen link ${projectId}\` bila hanya ingin mengikat, atau ulangi dengan --force.`
+    );
+  }
 }
 async function assertLinkTarget(target, projectId) {
   if (!await hasBundleMarkers(target)) {
@@ -9605,7 +9751,7 @@ function isMissingFile4(error) {
 }
 
 // src/index.ts
-var VERSION = "0.2.1";
+var VERSION = "0.2.2";
 var USAGE = `jioogen \u2014 CLI JiooGen (task selection lokal, server read-only)
 
 Usage:
@@ -9614,14 +9760,14 @@ Usage:
   jioogen logout
   jioogen whoami
   jioogen projects
-  jioogen pull <projectId> [--dir <dir>]
+  jioogen pull <projectId> [--dir <dir>] [--force]
   jioogen link <projectId> [--dir <dir>]
   jioogen skills install [--dir <dir>]
   jioogen check [--dir <dir>] [--json]
   jioogen handoff [--project <id>] [--json]
   jioogen task next [--json]
   jioogen task start <ref>
-  jioogen task complete <ref> [--note <text>]
+  jioogen task complete <ref> [--note <text>] [--force]
   jioogen task fail <ref> [reason...] [--note <text>]
   jioogen task reset <ref> [reason...] [--note <text>]
   jioogen status [--remote] [--json]
@@ -9637,8 +9783,6 @@ Global options:
   -h, --help        Tampilkan bantuan
   -v, --version     Tampilkan versi
 `;
-var UsageError = class extends Error {
-};
 async function main() {
   let raw = {};
   let positionals = [];
@@ -9655,6 +9799,7 @@ async function main() {
         project: { type: "string" },
         dir: { type: "string" },
         remote: { type: "boolean" },
+        force: { type: "boolean" },
         files: { type: "string" },
         note: { type: "string" },
         json: { type: "boolean" },
@@ -9680,6 +9825,7 @@ async function main() {
     project: text(raw.project),
     dir: text(raw.dir),
     remote: flag(raw.remote),
+    force: flag(raw.force),
     files: text(raw.files),
     note: text(raw.note),
     json: flag(raw.json)