@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/lib/setup-journal.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Undo journal for `zeroshot setup apply` / `zeroshot setup undo`.
  *
@@ -7,103 +8,145 @@
  * Shared by lib/setup-apply.js (writer) and lib/setup-undo.js (reader) so the
  * nested-path mutation and equality semantics can't drift between the two.
  */
-
-const fs = require('fs');
-const path = require('path');
+const fs = require("fs");
+const path = require("path");
+// These CommonJS paths intentionally resolve beside the emitted module in lib/.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { getSettingsFile } = require('./settings');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { getNestedValue } = require('./setup-plan');
-
 function getJournalPath() {
-  return path.join(path.dirname(getSettingsFile()), 'setup-undo-journal.json');
+    return path.join(path.dirname(getSettingsFile()), 'setup-undo-journal.json');
 }
-
-function loadJournal() {
-  const journalPath = getJournalPath();
-  if (!fs.existsSync(journalPath)) {
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isSetupJournal(value) {
+    return isRecord(value) && Array.isArray(value.entries);
+}
+function emptyJournal() {
     return { version: 1, entries: [] };
-  }
-  try {
-    const parsed = JSON.parse(fs.readFileSync(journalPath, 'utf8'));
-    if (!parsed || !Array.isArray(parsed.entries)) {
-      return { version: 1, entries: [] };
+}
+function loadJournal() {
+    const journalPath = getJournalPath();
+    if (!fs.existsSync(journalPath)) {
+        return emptyJournal();
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(journalPath, 'utf8'));
+        if (!isSetupJournal(parsed)) {
+            return emptyJournal();
+        }
+        return parsed;
+    }
+    catch {
+        return emptyJournal();
     }
-    return parsed;
-  } catch {
-    return { version: 1, entries: [] };
-  }
 }
-
 function saveJournal(journal) {
-  const journalPath = getJournalPath();
-  fs.mkdirSync(path.dirname(journalPath), { recursive: true });
-  fs.writeFileSync(journalPath, JSON.stringify(journal, null, 2), 'utf8');
+    const journalPath = getJournalPath();
+    fs.mkdirSync(path.dirname(journalPath), { recursive: true });
+    fs.writeFileSync(journalPath, JSON.stringify(journal, null, 2), 'utf8');
 }
-
 function entryKey(entry) {
-  return `${entry.scope}:${entry.repoRoot || ''}:${entry.path}`;
+    return `${entry.scope}:${entry.repoRoot || ''}:${entry.path}`;
 }
-
 // Re-applying an already-journaled write updates appliedValue/appliedAt but
 // keeps the original priorValue — that's the true pre-apply state undo must
 // restore to, and it must not drift across repeated `apply` runs.
 function upsertJournalEntry(journal, entry) {
-  const key = entryKey(entry);
-  const existingIndex = journal.entries.findIndex((e) => entryKey(e) === key);
-  if (existingIndex === -1) {
-    journal.entries.push(entry);
-    return;
-  }
-  journal.entries[existingIndex] = {
-    ...entry,
-    priorValue: journal.entries[existingIndex].priorValue,
-  };
+    const key = entryKey(entry);
+    const existingIndex = journal.entries.findIndex((candidate) => entryKey(candidate) === key);
+    if (existingIndex === -1) {
+        journal.entries.push(entry);
+        return;
+    }
+    const existing = journal.entries[existingIndex];
+    if (!existing) {
+        throw new Error('Journal entry disappeared during synchronous update');
+    }
+    journal.entries[existingIndex] = {
+        ...entry,
+        priorValue: existing.priorValue,
+    };
+}
+function safePathSegments(pathStr) {
+    const keys = pathStr.split('.');
+    for (const key of keys) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            throw new Error(`Unsafe setup journal path: ${pathStr}`);
+        }
+    }
+    return keys;
+}
+function defineOwnValue(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true,
+    });
 }
-
 function setNestedValue(target, pathStr, value) {
-  const keys = pathStr.split('.');
-  let node = target;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (typeof node[key] !== 'object' || node[key] === null) {
-      node[key] = {};
+    const keys = safePathSegments(pathStr);
+    let node = target;
+    for (let index = 0; index < keys.length - 1; index++) {
+        const key = keys[index] || '';
+        const child = Object.hasOwn(node, key) ? node[key] : undefined;
+        if (isRecord(child)) {
+            node = child;
+        }
+        else {
+            const replacement = {};
+            defineOwnValue(node, key, replacement);
+            node = replacement;
+        }
     }
-    node = node[key];
-  }
-  node[keys[keys.length - 1]] = value;
+    defineOwnValue(node, keys[keys.length - 1] || '', value);
 }
-
 function deleteNestedKey(target, pathStr) {
-  const keys = pathStr.split('.');
-  let node = target;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (typeof node[key] !== 'object' || node[key] === null) return;
-    node = node[key];
-  }
-  delete node[keys[keys.length - 1]];
+    const keys = safePathSegments(pathStr);
+    let node = target;
+    for (let index = 0; index < keys.length - 1; index++) {
+        const key = keys[index] || '';
+        if (!Object.hasOwn(node, key))
+            return;
+        const child = node[key];
+        if (!isRecord(child))
+            return;
+        node = child;
+    }
+    const finalKey = keys[keys.length - 1] || '';
+    if (Object.hasOwn(node, finalKey)) {
+        delete node[finalKey];
+    }
 }
-
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
-  if (Array.isArray(a) !== Array.isArray(b)) return false;
-  if (Array.isArray(a)) {
-    if (a.length !== b.length) return false;
-    return a.every((v, i) => deepEqual(v, b[i]));
-  }
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
-  return aKeys.every((k) => Object.prototype.hasOwnProperty.call(b, k) && deepEqual(a[k], b[k]));
+function deepEqual(left, right) {
+    if (left === right)
+        return true;
+    if (!isRecord(left) || !isRecord(right))
+        return false;
+    if (Array.isArray(left) !== Array.isArray(right))
+        return false;
+    if (Array.isArray(left) && Array.isArray(right)) {
+        if (left.length !== right.length)
+            return false;
+        return left.every((value, index) => deepEqual(value, right[index]));
+    }
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) &&
+        deepEqual(Reflect.get(left, key), Reflect.get(right, key)));
 }
-
 module.exports = {
-  getJournalPath,
-  loadJournal,
-  saveJournal,
-  upsertJournalEntry,
-  getNestedValue,
-  setNestedValue,
-  deleteNestedKey,
-  deepEqual,
+    getJournalPath,
+    loadJournal,
+    saveJournal,
+    upsertJournalEntry,
+    getNestedValue,
+    setNestedValue,
+    deleteNestedKey,
+    deepEqual,
 };

package/lib/setup-plan-types.d.ts

@@ -0,0 +1,102 @@
+export type SettingsMap = Record<string, unknown>;
+export type DecisionScope = 'global' | 'repo';
+export interface DecisionTarget {
+    path: string;
+    scope: DecisionScope;
+}
+export interface SetupEnvironment {
+    CI?: string;
+    __isTTY?: boolean;
+    npm_config_global?: string;
+    npm_execpath?: string;
+}
+interface ProviderMetadata {
+    binary: string;
+    displayName: string;
+    installInstructions: string;
+}
+interface ProviderAdapter {
+    cliCommand?: string;
+    isAvailable(): boolean;
+}
+export interface ProviderLevelDefaults {
+    defaultLevel?: unknown;
+    maxLevel?: unknown;
+    minLevel?: unknown;
+}
+export interface SetupPlanDependencies {
+    checkDocker(): {
+        available: unknown;
+    };
+    checkGhAuth(): {
+        authenticated: unknown;
+    };
+    commandExists(command: string): boolean;
+    execSync(command: string, options: {
+        cwd: string;
+        encoding: 'utf8';
+        stdio: 'pipe';
+    }): string;
+    getCommandPath(command: string): string | null;
+    getDefaultProviderId(): string;
+    getNodeVersion(): string;
+    getPackageVersion(): string;
+    getProvider(name: string): ProviderAdapter;
+    getProviderDefaults(): Record<string, ProviderLevelDefaults | undefined>;
+    getProviderMetadata(name: string): ProviderMetadata;
+    listProviders(): string[];
+}
+export interface ProviderFact {
+    available: boolean;
+    displayName: string;
+    installInstructions: string;
+    path: string | null;
+}
+export interface SetupFacts {
+    docker: {
+        available: boolean;
+    };
+    git: {
+        branch: string | null;
+        ghAuthed: boolean | null;
+        ghAvailable: boolean;
+        isRepo: boolean;
+        remote: string | null;
+    };
+    node: {
+        installSource: string;
+        packageVersion: string;
+        version: string;
+    };
+    providers: Record<string, ProviderFact>;
+    settings: {
+        hasGlobal: boolean;
+        hasRepo: boolean;
+    };
+}
+export interface SetupDecision {
+    currentValue: unknown;
+    decisionId: string;
+    domain: string;
+}
+export interface ProposedWrite extends DecisionTarget {
+    decisionId: string;
+    from: unknown;
+    to: unknown;
+}
+export interface BuildSetupPlanParams {
+    cwd?: string;
+    deps?: Partial<SetupPlanDependencies>;
+    env?: SetupEnvironment;
+    repoSettings?: SettingsMap | null;
+    settings?: SettingsMap;
+}
+export interface SetupPlan {
+    decisions: SetupDecision[];
+    facts: SetupFacts;
+    proposedWrites: ProposedWrite[];
+    recommended: Record<string, unknown>;
+    risk: Record<string, string>;
+    schemaVersion: number;
+}
+export {};

package/lib/setup-plan-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/setup-plan.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Setup plan — read-only facts collector + the pinned, versioned setup contract.
+ *
+ * buildSetupPlan() is pure over its injected inputs: no direct process.env/fs
+ * reads for config data, no writes, no prompts. Everything downstream (apply,
+ * undo, the TTY wizard, agents) consumes the object this returns, so its shape
+ * (schemaVersion, facts, decisions, recommended, risk, proposedWrites) and the
+ * decisionId registry below are a stable contract — do not rename IDs or add a
+ * parallel run-mode field without updating every consumer.
+ */
+import type { BuildSetupPlanParams, DecisionTarget, SetupPlan } from './setup-plan-types';
+declare function isConsumedPath(scope: string, targetPath: string): boolean;
+declare function resolveDecisionPath(decisionId: string): DecisionTarget | null;
+declare function getNestedValue(source: unknown, pathStr: string): unknown;
+declare function domainFor(decisionId: string): string;
+/**
+ * Build the pinned, versioned setup contract. Pure over injected inputs —
+ * performs only cheap, read-only detection (no writes, no prompts).
+ */
+declare function buildSetupPlan({ cwd, settings, repoSettings, env, deps, }?: BuildSetupPlanParams): SetupPlan;
+declare const _default: {
+    buildSetupPlan: typeof buildSetupPlan;
+    resolveDecisionPath: typeof resolveDecisionPath;
+    domainFor: typeof domainFor;
+    DECISION_PATHS: Record<string, DecisionTarget>;
+    getNestedValue: typeof getNestedValue;
+    isConsumedPath: typeof isConsumedPath;
+    CONSUMED_PATHS: Set<string>;
+};
+export = _default;