@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.5

package/src/lifecycle/{mcp-index.ts → mcp-index.js}

@@ -15,7 +15,7 @@
 //
 // Only SELECTED servers are imported, so the cost is proportional to what is installed: a
 // one-server install pays for one doc, and an install with none produces no file at all.
-function renderMcpIndex(selectedServers: any[] | null | undefined): string | null {
+function renderMcpIndex(selectedServers                          )                {
   if (!selectedServers || selectedServers.length === 0) return null;
   const lines = ['# MCP short flags — this install'];
   for (const server of selectedServers) {

package/src/lifecycle/{policies.ts → policies.js}

@@ -5,30 +5,30 @@
 // Registry lifecycle policies are logical intent. This projection reports what a
 // harness may render and any human prerequisite; native event serialization stays
 // in the owning harness adapter.
-const { harnessFor } = require('../registry/index.ts');
+const { harnessFor } = require('../registry/index.js');
 
 const POLICY_STATUSES = new Set(['supported', 'different', 'unavailable', 'prerequisite']);
 
-function unique(values: any[]): any[] { return [...new Set(values.filter(Boolean))]; }
+function unique(values       )        { return [...new Set(values.filter(Boolean))]; }
 
-function policyFor(registry: any, id: string): any {
-  const policy = registry?.lifecycle?.find((item: any) => item.id === id);
+function policyFor(registry     , id        )      {
+  const policy = registry?.lifecycle?.find((item     ) => item.id === id);
   if (!policy) throw new Error(`Unknown lifecycle policy '${id}'`);
   return policy;
 }
 
-function renderPolicy(policy: any, harness: any): any {
+function renderPolicy(policy     , harness     )      {
   const mapping = policy?.mappings?.[harness.id];
   if (!mapping) throw new Error(`Lifecycle policy '${policy.id}' has no mapping for '${harness.id}'`);
-  const requiredCapabilities = (policy.requires || []).map((capability: string): [string, any] => {
+  const requiredCapabilities = (policy.requires || []).map((capability        )                => {
     const declaration = harness.capabilities?.[capability];
     if (!declaration) throw new Error(`Lifecycle policy '${policy.id}' requires unknown '${harness.id}' capability '${capability}'`);
     return [capability, declaration];
   });
-  const unavailableCapability = requiredCapabilities.find(([, declaration]: [string, any]) => declaration.status === 'unavailable');
+  const unavailableCapability = requiredCapabilities.find(([, declaration]               ) => declaration.status === 'unavailable');
   const prerequisites = unique([
     ...(mapping.prerequisites || []),
-    ...requiredCapabilities.flatMap(([, declaration]: [string, any]) => declaration.prerequisites || []),
+    ...requiredCapabilities.flatMap(([, declaration]               ) => declaration.prerequisites || []),
   ]);
   const capabilityStatus = unavailableCapability ? 'unavailable' : mapping.status;
   const unavailable = capabilityStatus === 'unavailable';
@@ -60,14 +60,14 @@ function renderPolicy(policy: any, harness: any): any {
 }
 
 /** Render policy status data for one harness without calling an adapter or writing state. */
-function renderPolicies(registry: any, { harness: harnessId, policyIds }: { harness?: string, policyIds?: string[] | null } = {}): any {
+function renderPolicies(registry     , { harness: harnessId, policyIds }                                                    = {})      {
   if (!harnessId) throw new Error('A harness id is required to render lifecycle policies');
   const harness = harnessFor(registry, harnessId);
   const policies = policyIds === undefined || policyIds === null
     ? registry.lifecycle
-    : policyIds.map((id: string) => policyFor(registry, id));
+    : policyIds.map((id        ) => policyFor(registry, id));
   if (!Array.isArray(policies)) throw new Error('Lifecycle policies must be an array');
-  return Object.freeze(policies.map((policy: any) => renderPolicy(policy, harness)));
+  return Object.freeze(policies.map((policy     ) => renderPolicy(policy, harness)));
 }
 
 module.exports = { POLICY_STATUSES, policyFor, renderPolicy, renderPolicies };

package/src/lifecycle/{view.ts → view.js}

@@ -8,21 +8,21 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { parseToml } = require('../helper/toml.ts');
-const { createAdapterRegistry } = require('../adapters/index.ts');
-const { declaredHarnessPaths } = require('../helper/harness-paths.ts');
-const claudeAdapter = require('../adapters/claude/index.ts');
-const codexAdapter = require('../adapters/codex/index.ts');
-const { createGeminiAdapter } = require('../adapters/gemini/index.ts');
-const { createOpenCodeAdapter } = require('../adapters/opencode/index.ts');
-const { createPiAdapter } = require('../adapters/pi/index.ts');
-const { createCopilotAdapter } = require('../adapters/copilot/index.ts');
-const { createKiroAdapter } = require('../adapters/kiro/index.ts');
-const { createAntigravityAdapter } = require('../adapters/antigravity/index.ts');
-const { planLifecycle } = require('./index.ts');
-const { stateRoot, readLedger, defaultLedger } = require('../state/index.ts');
-const { selectAssets } = require('../registry/index.ts');
-const { defaultLock, readLock, writeLock, diffLocks, removeLock, pinnedSelections } = require('../state/lockfile.ts');
+const { parseToml } = require('../helper/toml.js');
+const { createAdapterRegistry } = require('../adapters/index.js');
+const { declaredHarnessPaths } = require('../helper/harness-paths.js');
+const claudeAdapter = require('../adapters/claude/index.js');
+const codexAdapter = require('../adapters/codex/index.js');
+const { createGeminiAdapter } = require('../adapters/gemini/index.js');
+const { createOpenCodeAdapter } = require('../adapters/opencode/index.js');
+const { createPiAdapter } = require('../adapters/pi/index.js');
+const { createCopilotAdapter } = require('../adapters/copilot/index.js');
+const { createKiroAdapter } = require('../adapters/kiro/index.js');
+const { createAntigravityAdapter } = require('../adapters/antigravity/index.js');
+const { planLifecycle } = require('./index.js');
+const { stateRoot, readLedger, defaultLedger } = require('../state/index.js');
+const { selectAssets } = require('../registry/index.js');
+const { defaultLock, readLock, writeLock, diffLocks, removeLock, pinnedSelections } = require('../state/lockfile.js');
 // Tolerant because the projected runtime under `.doflow/runtime/` ships bin/, src/ and
 // core/registry/ but no package.json — see the `runtime.*` assets in core/registry/assets.json.
 // A hard require here would make every Node-backed verb fail in an install, which is the exact
@@ -32,9 +32,9 @@ function loadPkg() {
 }
 const pkg = loadPkg();
 
-function codexScope(scope: any) { return scope.global ? 'global' : 'project'; }
+function codexScope(scope     ) { return scope.global ? 'global' : 'project'; }
 
-function codexConfigResources(repoRoot: any, fsImpl: any) {
+function codexConfigResources(repoRoot     , fsImpl     ) {
   const configSrc = path.join(repoRoot, 'core', 'harnesses', 'codex', 'config', 'config.toml');
   const parsed = parseToml(fsImpl.readFileSync(configSrc, 'utf8'));
   return [...parsed.entries.entries()].map(([identity, entry]) => ({
@@ -48,7 +48,7 @@ function codexConfigResources(repoRoot: any, fsImpl: any) {
  * mutation path until every native adapter has CLI-level parity.
  * `registry` is loaded once per command (by the caller) and threaded through here rather than
  * reloaded — the same registry also resolves every harness's MCP selection for that command. */
-function registryLifecycleView({ registry, scope, targets, mcpSelections = {}, mcpAdoptable = {}, retainedMcpIds = [], operation, repoRoot, force = false, adopt = false, permissions = false, statusline = false, fsImpl = fs }: any) {
+function registryLifecycleView({ registry, scope, targets, mcpSelections = {}, mcpAdoptable = {}, retainedMcpIds = [], operation, repoRoot, force = false, adopt = false, permissions = false, statusline = false, fsImpl = fs }     ) {
   const lifecycleScope = codexScope(scope);
   const scopeRoot = scope.global ? os.homedir() : path.resolve(scope.projectRoot);
   const neutralStateRoot = stateRoot({ scope: lifecycleScope, projectRoot: scopeRoot, homeDir: scopeRoot });
@@ -79,11 +79,11 @@ function registryLifecycleView({ registry, scope, targets, mcpSelections = {}, m
   return { registry, stateRoot: neutralStateRoot, ledger, plan, adapters };
 }
 
-function printRegistryLifecycle(view: any, prefix = '[PLAN]') {
+function printRegistryLifecycle(view     , prefix = '[PLAN]') {
   console.log(`${prefix} Registry lifecycle: ${view.plan.changes.length} native change(s), ${view.plan.conflicts.length} conflict(s), ${view.plan.prerequisites.length} prerequisite(s)`);
   for (const target of view.plan.targets) {
     console.log(`${prefix}   ${target.harness}: ${target.changes.length} change(s)${target.conflicts.length ? `; conflicts: ${target.conflicts.join('; ')}` : ''}`);
-    const hookChange = target.changes.find((change: any) => change.nativeComponent === 'hooks');
+    const hookChange = target.changes.find((change     ) => change.nativeComponent === 'hooks');
     if (hookChange?.nativePlan?.trust?.required) {
       console.log(`${prefix}   ${target.harness} hooks trust: ${hookChange.nativePlan.trust.status} (review required in ${target.harness})`);
     }
@@ -94,7 +94,7 @@ function printRegistryLifecycle(view: any, prefix = '[PLAN]') {
 
 /** Prints the plan's notices after a real run. Independent of whether anything changed: a no-op
  * reinstall of a harness that has a gap must still say so. */
-function printPlanNotices(view: any) {
+function printPlanNotices(view     ) {
   for (const { harness, notice } of view.plan.notices) console.log(`[INFO] ${harness}: ${notice}`);
 }
 
@@ -103,7 +103,7 @@ function printPlanNotices(view: any) {
  * src/targets.js — so a future non-lifecycle target doesn't silently gain lifecycle behavior. */
 const LIFECYCLE_HARNESSES = ['claude', 'codex', 'gemini', 'opencode', 'pi', 'copilot', 'kiro', 'antigravity'];
 
-function assertSafeRegistryPlan(view: any) {
+function assertSafeRegistryPlan(view     ) {
   if (view.plan.safe) return;
   for (const conflict of view.plan.conflicts) console.error(`[ERROR] ${conflict.harness} lifecycle refused: ${conflict.reason}`);
   for (const prerequisite of view.plan.prerequisites) console.error(`[ERROR] ${prerequisite.harness} lifecycle prerequisite: ${prerequisite.prerequisite}`);
@@ -119,9 +119,9 @@ function assertSafeRegistryPlan(view: any) {
  * selections carry over for pinned harnesses and are replaced by the rows this run resolved, `[]`
  * included. Assets are recomputed from the registry for every pinned harness. `null` when no harness
  * stays pinned. */
-function lockDocument({ registry, scope, scopeRoot, previous = null, ledger, plannedTargets = [], mcpSelections = {}, sourceVersion = pkg.version, now = new Date() }: any) {
-  const held = new Set((ledger?.resources ?? []).map((resource: any) => resource?.harness));
-  const pinned = [...new Set([...(previous?.targets ?? []).map((entry: any) => entry.harness), ...plannedTargets])]
+function lockDocument({ registry, scope, scopeRoot, previous = null, ledger, plannedTargets = [], mcpSelections = {}, sourceVersion = pkg.version, now = new Date() }     ) {
+  const held = new Set((ledger?.resources ?? []).map((resource     ) => resource?.harness));
+  const pinned = [...new Set([...(previous?.targets ?? []).map((entry     ) => entry.harness), ...plannedTargets])]
     .filter((harness) => held.has(harness)).sort();
   if (!pinned.length) return null;
   const assets = [];
@@ -145,13 +145,13 @@ function lockDocument({ registry, scope, scopeRoot, previous = null, ledger, pla
 /** Describe the reviewable delta between the pinned lock and the next one: "created" for a first
  * pin, "unchanged" when nothing pinned differs, "cleared" when nothing remains pinned, else a count
  * of the changed rows. */
-function lockDelta(previous: any, next: any) {
+function lockDelta(previous     , next     ) {
   if (!next) return previous ? { changed: true, summary: 'cleared' } : { changed: false, summary: 'unchanged' };
   if (!previous) return { changed: true, summary: 'created' };
   const diff = diffLocks(previous, next);
   if (diff.clean) return { changed: false, summary: 'unchanged' };
   const count = ['targets', 'assets']
-    .flatMap((section) => Object.values<any>(diff[section]).map((list: any) => list.length))
+    .flatMap((section) => Object.values     (diff[section]).map((list     ) => list.length))
     .reduce((sum, n) => sum + n, 0)
     + diff.mcpSelections.changed.length + (diff.meta.sourceVersion ? 1 : 0);
   return { changed: true, summary: `${count} change(s)` };
@@ -160,7 +160,7 @@ function lockDelta(previous: any, next: any) {
 /** Persist the lock for a completed command and return its delta against what was pinned before.
  * An unchanged lock is left byte for byte, so routine re-runs neither rewrite the file nor
  * manufacture noise; a `null` lock removes the file. */
-function recordLock(scopeArgs: any, next: any, { fsImpl = fs }: any = {}) {
+function recordLock(scopeArgs     , next     , { fsImpl = fs }      = {}) {
   const delta = lockDelta(readLock(scopeArgs, { fsImpl }), next);
   if (delta.changed) {
     if (next) writeLock(scopeArgs, next, { fsImpl });