fifony 0.1.42 → 0.1.43

package/dist/cli.js

@@ -1,16 +1,41 @@
 import {
+  applyPersistedSettings,
+  bootstrapDevProfile,
+  buildProbeResult,
+  closeStateStore,
+  collectRuntimeHealthSnapshot,
+  getDevProfileStatus,
+  initStateStore,
+  loadPersistedMilestones,
+  loadPersistedServices,
+  loadPersistedState,
+  loadRuntimeSettings,
+  resetDevProfile,
+  runDoctorChecks
+} from "./chunk-YRSH2CLW.js";
+import "./chunk-BRSR26VK.js";
+import "./chunk-QQQLP3PL.js";
+import "./chunk-AILXZ2TD.js";
+import "./chunk-SOBLO4YZ.js";
+import {
+  applyWorkflowConfig,
+  buildRuntimeState,
+  deriveConfig,
   getReferenceRepositoriesRoot,
   importReferenceArtifacts,
   listReferenceRepositories,
+  resolveProjectMetadata,
   syncReferenceRepositories
-} from "./chunk-JTKUWIQD.js";
-import "./chunk-RBDBGU2C.js";
-import "./chunk-I2UHVKHS.js";
-import "./chunk-H5N7O5NP.js";
-import "./chunk-NB44PCD2.js";
-import "./chunk-2CVTK5F2.js";
-import "./chunk-37N5OFHM.js";
+} from "./chunk-E2EWEYA4.js";
+import "./chunk-MVTGAKQK.js";
+import "./chunk-FJNH3G2Z.js";
 import "./chunk-DVU3CXWA.js";
+import "./chunk-ESWHDHH6.js";
+import {
+  now,
+  resolvePersistenceRoot
+} from "./chunk-42AMQAJG.js";
+import "./chunk-3NE23NYW.js";
 
 // src/cli.ts
 import { spawn } from "child_process";
@@ -98,6 +123,114 @@ function getWorkspaceRoot(result) {
   const workspace = getStringOption(result, "workspace");
   return resolve(workspace ?? env.FIFONY_WORKSPACE_ROOT ?? cwd());
 }
+function getStateRoot(result) {
+  const persistence = getStringOption(result, "persistence");
+  return resolvePersistenceRoot(
+    persistence ?? env.FIFONY_PERSISTENCE ?? getWorkspaceRoot(result)
+  );
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function printKeyValue(label, value) {
+  console.log(`${label}: ${value ?? "n/a"}`);
+}
+async function loadRuntimeStateSnapshot(result) {
+  const workspaceRoot = getWorkspaceRoot(result);
+  const port = getNumberOption(result, "port");
+  await initStateStore();
+  try {
+    let config = applyWorkflowConfig(deriveConfig(buildRuntimeArgs(result)), port);
+    const [previous, settings, services, milestones] = await Promise.all([
+      loadPersistedState(),
+      loadRuntimeSettings(),
+      loadPersistedServices(),
+      loadPersistedMilestones()
+    ]);
+    config = applyPersistedSettings(config, settings);
+    if (services.length > 0) {
+      config = { ...config, services };
+    }
+    return buildRuntimeState(
+      previous,
+      config,
+      resolveProjectMetadata(settings, workspaceRoot),
+      milestones
+    );
+  } finally {
+    await closeStateStore();
+  }
+}
+async function runStatus(result) {
+  const json = getBooleanOption(result, "json");
+  const includeAll = getBooleanOption(result, "all");
+  const state = await loadRuntimeStateSnapshot(result);
+  const snapshot = collectRuntimeHealthSnapshot(state);
+  if (json) {
+    printJson(includeAll ? {
+      generatedAt: now(),
+      snapshot,
+      probe: buildProbeResult(state),
+      doctor: runDoctorChecks(state)
+    } : snapshot);
+    return;
+  }
+  console.log("Fifony Runtime Status");
+  printKeyValue("Generated", snapshot.generatedAt);
+  printKeyValue("Workspace", snapshot.workspace.root);
+  printKeyValue("Healthy", snapshot.ok);
+  printKeyValue("Configured provider", snapshot.providers.configuredProvider);
+  printKeyValue("Issues", snapshot.issues.total);
+  printKeyValue("Running issues", snapshot.issues.running);
+  printKeyValue("Reviewing issues", snapshot.issues.reviewing);
+  printKeyValue("Services running", `${snapshot.services.running}/${snapshot.services.total}`);
+  printKeyValue("Active agents", snapshot.agents.active);
+  printKeyValue("Memory flushes", snapshot.memory.totalFlushes);
+  if (!includeAll) return;
+  console.log("");
+  console.log("Doctor");
+  for (const check of runDoctorChecks(state)) {
+    console.log(`- [${check.status}] ${check.title}: ${check.summary}`);
+  }
+}
+async function runProbe(result) {
+  const json = getBooleanOption(result, "json");
+  const state = await loadRuntimeStateSnapshot(result);
+  const probe = buildProbeResult(state);
+  if (json) {
+    printJson(probe);
+    return;
+  }
+  console.log(`Probe: ${probe.ok ? "ok" : "degraded"}`);
+  for (const check of probe.checks) {
+    console.log(`- [${check.ok ? "ok" : "fail"}] ${check.id}: ${check.detail}`);
+  }
+}
+async function runDoctor(result) {
+  const json = getBooleanOption(result, "json");
+  const state = await loadRuntimeStateSnapshot(result);
+  const checks = runDoctorChecks(state);
+  const payload = {
+    ok: checks.every((check) => check.status !== "fail"),
+    generatedAt: now(),
+    checks
+  };
+  if (json) {
+    printJson(payload);
+    return;
+  }
+  console.log("Fifony Doctor");
+  for (const check of checks) {
+    console.log(`- [${check.status}] ${check.title}`);
+    console.log(`  ${check.summary}`);
+    if (check.detail) {
+      console.log(`  detail: ${check.detail}`);
+    }
+    if (check.suggestedAction) {
+      console.log(`  action: ${check.suggestedAction}`);
+    }
+  }
+}
 async function runOnboardingList() {
   const root = getReferenceRepositoriesRoot();
   const repositories = listReferenceRepositories();
@@ -209,10 +342,13 @@ async function runOnboardingImport(result) {
   }
 }
 function buildRuntimeArgs(result) {
+  return buildRuntimeArgsWithOverrides(result);
+}
+function buildRuntimeArgsWithOverrides(result, overrides = {}) {
   const runtimeArgs = [];
-  const workspace = getStringOption(result, "workspace");
-  const persistence = getStringOption(result, "persistence");
-  const port = getNumberOption(result, "port");
+  const workspace = overrides.workspace ?? getStringOption(result, "workspace");
+  const persistence = overrides.persistence ?? getStringOption(result, "persistence");
+  const port = overrides.port ?? getNumberOption(result, "port");
   const concurrency = getNumberOption(result, "concurrency");
   const attempts = getNumberOption(result, "attempts");
   const poll = getNumberOption(result, "poll");
@@ -242,20 +378,13 @@ function buildRuntimeArgs(result) {
   }
   return runtimeArgs;
 }
-async function runRuntime(mode, result) {
-  const workspace = getStringOption(result, "workspace");
-  const workspaceRoot = resolve(workspace ?? env.FIFONY_WORKSPACE_ROOT ?? cwd());
-  const runtimeArgs = buildRuntimeArgs(result);
+async function runNodeEntry(script, args2, runtimeCwd, runtimeEnv) {
   const outcome = await new Promise((resolvePromise, rejectPromise) => {
-    const args2 = useCompiled ? [runtimeScript, ...runtimeArgs] : [tsxCli, runtimeScript, ...runtimeArgs];
-    const child = spawn(execPath, args2, {
-      cwd: workspaceRoot,
+    const childArgs = useCompiled ? [script, ...args2] : [tsxCli, script, ...args2];
+    const child = spawn(execPath, childArgs, {
+      cwd: runtimeCwd,
       stdio: "inherit",
-      env: {
-        ...env,
-        FIFONY_INTERFACE: mode,
-        FIFONY_WORKSPACE_ROOT: workspaceRoot
-      }
+      env: runtimeEnv
     });
     child.on("exit", (code, signal) => {
       resolvePromise({ code, signal });
@@ -272,36 +401,103 @@ async function runRuntime(mode, result) {
     exit(outcome.code);
   }
 }
+async function runRuntimeProcess(mode, workspaceRoot, persistenceRoot, runtimeArgs) {
+  await runNodeEntry(runtimeScript, runtimeArgs, workspaceRoot, {
+    ...env,
+    FIFONY_INTERFACE: mode,
+    FIFONY_WORKSPACE_ROOT: workspaceRoot,
+    FIFONY_PERSISTENCE: persistenceRoot
+  });
+}
+async function runRuntime(mode, result) {
+  const workspace = getStringOption(result, "workspace");
+  const persistence = getStringOption(result, "persistence");
+  const workspaceRoot = resolve(workspace ?? env.FIFONY_WORKSPACE_ROOT ?? cwd());
+  const persistenceRoot = resolvePersistenceRoot(persistence ?? env.FIFONY_PERSISTENCE ?? workspaceRoot);
+  const runtimeArgs = buildRuntimeArgs(result);
+  await runRuntimeProcess(mode, workspaceRoot, persistenceRoot, runtimeArgs);
+}
 async function runMcpServer(result) {
   const workspace = getStringOption(result, "workspace");
   const persistence = getStringOption(result, "persistence");
   const workspaceRoot = resolve(workspace ?? env.FIFONY_WORKSPACE_ROOT ?? cwd());
-  const persistenceRoot = resolve(persistence ?? env.FIFONY_PERSISTENCE ?? workspaceRoot);
-  const outcome = await new Promise((resolvePromise, rejectPromise) => {
-    const mcpArgs = useCompiled ? [mcpScript] : [tsxCli, mcpScript];
-    const child = spawn(execPath, mcpArgs, {
-      cwd: workspaceRoot,
-      stdio: "inherit",
-      env: {
-        ...env,
-        FIFONY_WORKSPACE_ROOT: workspaceRoot,
-        FIFONY_PERSISTENCE: persistenceRoot
-      }
-    });
-    child.on("exit", (code, signal) => {
-      resolvePromise({ code, signal });
-    });
-    child.on("error", (error) => {
-      rejectPromise(error);
-    });
+  const persistenceRoot = resolvePersistenceRoot(persistence ?? env.FIFONY_PERSISTENCE ?? workspaceRoot);
+  await runNodeEntry(mcpScript, [], workspaceRoot, {
+    ...env,
+    FIFONY_WORKSPACE_ROOT: workspaceRoot,
+    FIFONY_PERSISTENCE: persistenceRoot
   });
-  if (outcome.signal) {
-    kill(pid, outcome.signal);
+}
+function printDevProfileStatus(profile) {
+  console.log("Fifony Dev Profile");
+  printKeyValue("Profile", profile.profileName);
+  printKeyValue("Workspace", profile.workspaceRoot);
+  printKeyValue("Persistence", profile.persistenceRoot);
+  printKeyValue("Branch", profile.branchName);
+  printKeyValue("Bootstrapped", profile.bootstrapped);
+  printKeyValue("Worktree attached", profile.worktreeAttached);
+  printKeyValue("Dashboard port", profile.dashboardPort);
+  printKeyValue("Trash entries", profile.trashEntries.length);
+  if (profile.lastBootstrappedAt) {
+    printKeyValue("Last bootstrap", profile.lastBootstrappedAt);
+  }
+  if (profile.lastResetAt) {
+    printKeyValue("Last reset", profile.lastResetAt);
+  }
+  console.log("");
+  console.log("Launch");
+  console.log(profile.launchCommand);
+}
+async function runDevStatus(result) {
+  const workspaceRoot = getWorkspaceRoot(result);
+  const json = getBooleanOption(result, "json");
+  const profile = getDevProfileStatus(workspaceRoot, getStateRoot(result));
+  if (json) {
+    printJson({ ok: true, profile });
     return;
   }
-  if (typeof outcome.code === "number" && outcome.code !== 0) {
-    exit(outcome.code);
+  printDevProfileStatus(profile);
+}
+async function runDevBootstrap(result) {
+  const workspaceRoot = getWorkspaceRoot(result);
+  const json = getBooleanOption(result, "json");
+  const profile = bootstrapDevProfile(workspaceRoot, getStateRoot(result));
+  if (json) {
+    printJson({ ok: true, profile });
+    return;
   }
+  printDevProfileStatus(profile);
+}
+async function runDevReset(result) {
+  const workspaceRoot = getWorkspaceRoot(result);
+  const stateRoot = getStateRoot(result);
+  const json = getBooleanOption(result, "json");
+  const resultPayload = resetDevProfile(workspaceRoot, stateRoot);
+  const profile = getDevProfileStatus(workspaceRoot, stateRoot);
+  if (json) {
+    printJson({ ok: true, result: resultPayload, profile });
+    return;
+  }
+  console.log("Dev profile reset");
+  printKeyValue("Removed worktree", resultPayload.removedWorktree);
+  printKeyValue("Trashed profile", resultPayload.trashedProfile);
+  if (resultPayload.trashPath) {
+    printKeyValue("Trash path", resultPayload.trashPath);
+  }
+  console.log("");
+  printDevProfileStatus(profile);
+}
+async function runDevRuntime(result) {
+  const targetWorkspaceRoot = getWorkspaceRoot(result);
+  const stateRoot = getStateRoot(result);
+  const profile = bootstrapDevProfile(targetWorkspaceRoot, stateRoot);
+  const port = getNumberOption(result, "port") ?? profile.dashboardPort;
+  const runtimeArgs = buildRuntimeArgsWithOverrides(result, {
+    workspace: profile.workspaceRoot,
+    persistence: profile.persistenceRoot,
+    port
+  });
+  await runRuntimeProcess("cli", profile.workspaceRoot, profile.persistenceRoot, runtimeArgs);
 }
 var cli = createCLI({
   name: packageJson.name ?? "fifony",
@@ -318,6 +514,101 @@ var cli = createCLI({
       options: commonOptions,
       handler: (result) => runMcpServer(result)
     },
+    dev: {
+      description: "Manage and run the isolated Fifony development profile.",
+      commands: {
+        status: {
+          description: "Show the current dev profile status and launch command.",
+          options: {
+            workspace: commonOptions.workspace,
+            persistence: commonOptions.persistence,
+            json: {
+              type: "boolean",
+              description: "Emit JSON instead of human-readable text."
+            }
+          },
+          handler: (result) => runDevStatus(result)
+        },
+        bootstrap: {
+          description: "Create or refresh the isolated dev profile worktree and bootstrap files.",
+          options: {
+            workspace: commonOptions.workspace,
+            persistence: commonOptions.persistence,
+            json: {
+              type: "boolean",
+              description: "Emit JSON instead of human-readable text."
+            }
+          },
+          handler: (result) => runDevBootstrap(result)
+        },
+        reset: {
+          description: "Safely move the dev profile to trash and remove its worktree branch.",
+          options: {
+            workspace: commonOptions.workspace,
+            persistence: commonOptions.persistence,
+            json: {
+              type: "boolean",
+              description: "Emit JSON instead of human-readable text."
+            }
+          },
+          handler: (result) => runDevReset(result)
+        },
+        run: {
+          description: "Launch the runtime against the isolated dev profile.",
+          options: {
+            ...commonOptions,
+            port: {
+              ...commonOptions.port,
+              default: 4100
+            }
+          },
+          handler: (result) => runDevRuntime(result)
+        }
+      }
+    },
+    status: {
+      description: "Show an operational snapshot of the local Fifony runtime state.",
+      options: {
+        workspace: commonOptions.workspace,
+        persistence: commonOptions.persistence,
+        port: commonOptions.port,
+        json: {
+          type: "boolean",
+          description: "Emit JSON instead of human-readable text."
+        },
+        all: {
+          type: "boolean",
+          description: "Include doctor details alongside the status snapshot."
+        }
+      },
+      handler: (result) => runStatus(result)
+    },
+    probe: {
+      description: "Run a fast readiness probe over workspace, providers, services, agents, and memory.",
+      options: {
+        workspace: commonOptions.workspace,
+        persistence: commonOptions.persistence,
+        port: commonOptions.port,
+        json: {
+          type: "boolean",
+          description: "Emit JSON instead of human-readable text."
+        }
+      },
+      handler: (result) => runProbe(result)
+    },
+    doctor: {
+      description: "Run detailed operational diagnostics for the local Fifony runtime.",
+      options: {
+        workspace: commonOptions.workspace,
+        persistence: commonOptions.persistence,
+        port: commonOptions.port,
+        json: {
+          type: "boolean",
+          description: "Emit JSON instead of human-readable text."
+        }
+      },
+      handler: (result) => runDoctor(result)
+    },
     onboarding: {
       description: "Manage reference repositories and import agents/skills from them.",
       aliases: ["onboard"],

package/dist/{issue-state-machine-GPQNZYUZ.js → fsm-issue-YGGF7SIL.js}

@@ -15,12 +15,15 @@ import {
   setFsmEventEmitter,
   setIssueResourceStateApi,
   setIssueStateMachinePlugin,
+  setPersistNowFn,
   visualizeStateMachine
-} from "./chunk-H5N7O5NP.js";
-import "./chunk-NB44PCD2.js";
-import "./chunk-2CVTK5F2.js";
-import "./chunk-37N5OFHM.js";
+} from "./chunk-AILXZ2TD.js";
+import "./chunk-SOBLO4YZ.js";
+import "./chunk-MVTGAKQK.js";
+import "./chunk-FJNH3G2Z.js";
 import "./chunk-DVU3CXWA.js";
+import "./chunk-ESWHDHH6.js";
+import "./chunk-42AMQAJG.js";
 export {
   ISSUE_STATE_MACHINE_ID,
   canTransitionIssue,
@@ -38,6 +41,7 @@ export {
   setFsmEventEmitter,
   setIssueResourceStateApi,
   setIssueStateMachinePlugin,
+  setPersistNowFn,
   visualizeStateMachine
 };
-//# sourceMappingURL=issue-state-machine-GPQNZYUZ.js.map
+//# sourceMappingURL=fsm-issue-YGGF7SIL.js.map

package/dist/helpers-L7NYO5XS.js

@@ -0,0 +1,53 @@
+import {
+  appendFileTail,
+  clamp,
+  debugBoot,
+  extractJsonObjects,
+  fail,
+  getNestedNumber,
+  getNestedRecord,
+  getNestedString,
+  idToSafePath,
+  isoWeek,
+  normalizeState,
+  now,
+  parseEnvNumber,
+  parseFrontMatter,
+  parseIntArg,
+  parseIssueState,
+  parsePositiveIntEnv,
+  repairTruncatedJson,
+  sleep,
+  toBooleanValue,
+  toNumberValue,
+  toStringArray,
+  toStringValue,
+  withRetryBackoff
+} from "./chunk-42AMQAJG.js";
+export {
+  appendFileTail,
+  clamp,
+  debugBoot,
+  extractJsonObjects,
+  fail,
+  getNestedNumber,
+  getNestedRecord,
+  getNestedString,
+  idToSafePath,
+  isoWeek,
+  normalizeState,
+  now,
+  parseEnvNumber,
+  parseFrontMatter,
+  parseIntArg,
+  parseIssueState,
+  parsePositiveIntEnv,
+  repairTruncatedJson,
+  sleep,
+  toBooleanValue,
+  toNumberValue,
+  toStringArray,
+  toStringValue,
+  withRetryBackoff
+};
+//# sourceMappingURL=helpers-L7NYO5XS.js.map

package/dist/issue-log-broadcaster-WZAHISYB.js

@@ -0,0 +1,84 @@
+import {
+  agentLogPath,
+  issueLogRoomSize,
+  sendToIssueLogRoom
+} from "./chunk-YRSH2CLW.js";
+import "./chunk-BRSR26VK.js";
+import "./chunk-QQQLP3PL.js";
+import "./chunk-AILXZ2TD.js";
+import "./chunk-SOBLO4YZ.js";
+import "./chunk-E2EWEYA4.js";
+import "./chunk-MVTGAKQK.js";
+import "./chunk-FJNH3G2Z.js";
+import {
+  logger
+} from "./chunk-DVU3CXWA.js";
+import "./chunk-ESWHDHH6.js";
+import "./chunk-42AMQAJG.js";
+import "./chunk-3NE23NYW.js";
+
+// src/persistence/plugins/issue-log-broadcaster.ts
+import {
+  closeSync,
+  existsSync,
+  openSync,
+  readSync,
+  statSync
+} from "fs";
+var POLL_INTERVAL_MS = 500;
+var MAX_CHUNK_BYTES = 16384;
+var active = /* @__PURE__ */ new Map();
+function readNewBytes(logPath, position) {
+  try {
+    const size = statSync(logPath).size;
+    if (size <= position) return null;
+    const toRead = Math.min(size - position, MAX_CHUNK_BYTES);
+    const buf = Buffer.alloc(toRead);
+    const fd = openSync(logPath, "r");
+    const n = readSync(fd, buf, 0, toRead, position);
+    closeSync(fd);
+    if (n <= 0) return null;
+    return { chunk: buf.slice(0, n).toString("utf8"), newPosition: position + n };
+  } catch {
+    return null;
+  }
+}
+function startIssueLogBroadcasting(issueId, workspacePath) {
+  stopIssueLogBroadcasting(issueId);
+  const logPath = agentLogPath(workspacePath);
+  const entry = { timerId: null, position: 0 };
+  const flush = () => {
+    if (!existsSync(logPath)) return;
+    try {
+      const size = statSync(logPath).size;
+      if (size < entry.position) entry.position = 0;
+      if (size <= entry.position) return;
+    } catch {
+      return;
+    }
+    const result = readNewBytes(logPath, entry.position);
+    if (!result) return;
+    entry.position = result.newPosition;
+    if (issueLogRoomSize(issueId) === 0) return;
+    sendToIssueLogRoom(issueId, JSON.stringify({ type: "issue:log", id: issueId, chunk: result.chunk }));
+  };
+  entry.timerId = setInterval(flush, POLL_INTERVAL_MS);
+  active.set(issueId, entry);
+  logger.debug({ issueId }, "[IssueLogBroadcaster] Started");
+}
+function stopIssueLogBroadcasting(issueId) {
+  const entry = active.get(issueId);
+  if (!entry) return;
+  clearInterval(entry.timerId);
+  active.delete(issueId);
+  logger.debug({ issueId }, "[IssueLogBroadcaster] Stopped");
+}
+function stopAllIssueLogBroadcasting() {
+  for (const id of [...active.keys()]) stopIssueLogBroadcasting(id);
+}
+export {
+  startIssueLogBroadcasting,
+  stopAllIssueLogBroadcasting,
+  stopIssueLogBroadcasting
+};
+//# sourceMappingURL=issue-log-broadcaster-WZAHISYB.js.map

package/dist/{issues-MZLRSXD6.js → issues-3QRR7KM6.js}

@@ -5,22 +5,22 @@ import {
   createIssueFromPayload,
   dedupHistoryEntries,
   deriveConfig,
+  getIssueTransitionExecutor,
   getNextRetryAt,
   issueDependenciesResolved,
   nextLocalIssueId,
   normalizeIssue,
+  setIssueTransitionExecutor,
   transitionIssue,
   validateConfig
-} from "./chunk-JTKUWIQD.js";
-import "./chunk-RBDBGU2C.js";
-import "./chunk-I2UHVKHS.js";
+} from "./chunk-E2EWEYA4.js";
 import {
   computeMetrics
-} from "./chunk-H5N7O5NP.js";
-import "./chunk-NB44PCD2.js";
-import "./chunk-2CVTK5F2.js";
-import "./chunk-37N5OFHM.js";
+} from "./chunk-MVTGAKQK.js";
+import "./chunk-FJNH3G2Z.js";
 import "./chunk-DVU3CXWA.js";
+import "./chunk-ESWHDHH6.js";
+import "./chunk-42AMQAJG.js";
 export {
   addEvent,
   applyWorkflowConfig,
@@ -29,11 +29,13 @@ export {
   createIssueFromPayload,
   dedupHistoryEntries,
   deriveConfig,
+  getIssueTransitionExecutor,
   getNextRetryAt,
   issueDependenciesResolved,
   nextLocalIssueId,
   normalizeIssue,
+  setIssueTransitionExecutor,
   transitionIssue,
   validateConfig
 };
-//# sourceMappingURL=issues-MZLRSXD6.js.map
+//# sourceMappingURL=issues-3QRR7KM6.js.map