@untangle-code/cli 0.0.0-stage → 0.1.1

package/dist/cli/embedder-deadline.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Eine Frist um JEDEN Aufruf des Einbettungsdienstes — und ein sichtbares
+ * Lebenszeichen, solange er laeuft.
+ *
+ * WARUM (WP-227, gemessen, nicht vermutet): Beim Abnahmelauf gegen ein
+ * Projekt mit NEUN Dateien lief `untangle index` ueber 300 Sekunden ohne eine
+ * einzige Zeile Ausgabe und musste abgebrochen werden. Ursache war ein
+ * Ollama, dessen `/api/embed` haengt, waehrend `/api/tags` sofort antwortet.
+ * Die Rechnung dahinter: `embeddings.requestTimeoutMs` steht per Vorgabe auf
+ * 120 000 ms, und die Bereitschaftsfolge wiederholt ihren Zeitueberlauf mit
+ * Backoff — drei Versuche sind sechs Minuten. Fuer den Indexlauf ist langes
+ * Durchhalten grundsaetzlich richtig; ein Mensch am Terminal, der nichts
+ * sieht, weiss aber nicht einmal, OB etwas passiert. Das ist die
+ * Oberflaechenform derselben Unehrlichkeit, gegen die E4 antritt.
+ *
+ * ES IST DASSELBE MUSTER WIE IN `untangle doctor`: eine eigene Frist der
+ * Oberflaeche, und ein abgebrochener Aufruf gilt als FEHLGESCHLAGEN, nie als
+ * bestanden. Der Unterschied ist nur, dass die Frist hier nicht um einen
+ * Diagnosetest liegt, sondern um jeden einzelnen Aufruf des Dienstes.
+ *
+ * ZWEI DINGE, DIE DIESE HUELLE NIE TUT:
+ *
+ * 1. Sie faelscht kein Ergebnis. Laeuft die Frist ab, wirft sie
+ *    `EMBEDDING_UNAVAILABLE` — nie einen leeren Vektorsatz, der weiter unten
+ *    als „fertig" durchginge (spec.md §25.1, BUILD_PLAN E4).
+ * 2. Sie taeuscht keinen Nutzerabbruch vor. Ein Fristablauf traegt bewusst
+ *    NICHT den Namen `AbortError` und nicht den Code `JOB_CANCELLED`: der
+ *    Laeufer unterscheidet Abbruch von Fehlschlag genau daran (siehe
+ *    `packages/core/src/cancellation.ts`), und ein Fristablauf ist ein
+ *    Fehlschlag der UMGEBUNG, kein Strg-C. Bricht dagegen der Nutzer wirklich
+ *    ab, geht sein Fehler unveraendert weiter.
+ */
+import { type EmbeddingProvider } from "@untangle-code/domain";
+/**
+ * Vorgabefrist je Aufruf.
+ *
+ * Grosszuegiger als die 15 s von `doctor`, weil ein Indexstapel echte Arbeit
+ * ist (acht Dateien, ein kalt geladenes Modell) — und trotzdem endlich, weil
+ * genau das der Unterschied zwischen „dauert" und „haengt" ist. Wem sie zu
+ * knapp ist, der hebt sie mit `--timeout` an; wer schnell scheitern will,
+ * senkt sie.
+ */
+export declare const DEFAULT_EMBEDDING_TIMEOUT_MS = 60000;
+/** Abstand der Lebenszeichen, solange ein Aufruf laeuft. */
+export declare const DEFAULT_HEARTBEAT_MS = 5000;
+export interface EmbeddingDeadlineOptions {
+    /** Frist je Aufruf in Millisekunden. */
+    readonly timeoutMs: number;
+    /**
+     * Das Abbruchsignal des Befehls. Es gilt zusaetzlich zu dem, das der
+     * Aufrufer je Aufruf mitgibt — Strg-C wirkt sofort, nicht erst zur Frist.
+     */
+    readonly outerSignal: AbortSignal;
+    /** Wohin die Lebenszeichen gehen. In der Oberflaeche: stderr. */
+    readonly onProgress?: ((text: string) => void) | undefined;
+    /** Abstand der Lebenszeichen; 0 schaltet sie ab. */
+    readonly heartbeatMs?: number | undefined;
+    /**
+     * Die Uhr der Lebenszeichen. Vorgabe ist der `systemClock`-Port — nie
+     * `Date.now()` direkt (spec.md §5, Regel 5). Die gemessene Dauer ist
+     * DIAGNOSE auf stderr und geht in keine Ergebnisdatei ein.
+     */
+    readonly clock?: {
+        nowEpochMs(): number;
+    } | undefined;
+}
+/**
+ * Legt {@link EmbeddingDeadlineOptions.timeoutMs} um jeden Aufruf von
+ * `inner` und meldet, dass gewartet wird.
+ */
+export declare function withEmbeddingDeadline(inner: EmbeddingProvider, options: EmbeddingDeadlineOptions): EmbeddingProvider;
+//# sourceMappingURL=embedder-deadline.d.ts.map

package/dist/cli/embedder-deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedder-deadline.d.ts","sourceRoot":"","sources":["../../src/cli/embedder-deadline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAIL,KAAK,iBAAiB,EAGvB,MAAM,uBAAuB,CAAC;AAK/B;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAEnD,4DAA4D;AAC5D,eAAO,MAAM,oBAAoB,OAAQ,CAAC;AAE1C,MAAM,WAAW,wBAAwB;IACvC,wCAAwC;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,iEAAiE;IACjE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAC3D,oDAAoD;IACpD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,UAAU,IAAI,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;CACvD;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,wBAAwB,GAChC,iBAAiB,CA8FnB"}

package/dist/cli/embedder-deadline.js

@@ -0,0 +1,117 @@
+/**
+ * Eine Frist um JEDEN Aufruf des Einbettungsdienstes — und ein sichtbares
+ * Lebenszeichen, solange er laeuft.
+ *
+ * WARUM (WP-227, gemessen, nicht vermutet): Beim Abnahmelauf gegen ein
+ * Projekt mit NEUN Dateien lief `untangle index` ueber 300 Sekunden ohne eine
+ * einzige Zeile Ausgabe und musste abgebrochen werden. Ursache war ein
+ * Ollama, dessen `/api/embed` haengt, waehrend `/api/tags` sofort antwortet.
+ * Die Rechnung dahinter: `embeddings.requestTimeoutMs` steht per Vorgabe auf
+ * 120 000 ms, und die Bereitschaftsfolge wiederholt ihren Zeitueberlauf mit
+ * Backoff — drei Versuche sind sechs Minuten. Fuer den Indexlauf ist langes
+ * Durchhalten grundsaetzlich richtig; ein Mensch am Terminal, der nichts
+ * sieht, weiss aber nicht einmal, OB etwas passiert. Das ist die
+ * Oberflaechenform derselben Unehrlichkeit, gegen die E4 antritt.
+ *
+ * ES IST DASSELBE MUSTER WIE IN `untangle doctor`: eine eigene Frist der
+ * Oberflaeche, und ein abgebrochener Aufruf gilt als FEHLGESCHLAGEN, nie als
+ * bestanden. Der Unterschied ist nur, dass die Frist hier nicht um einen
+ * Diagnosetest liegt, sondern um jeden einzelnen Aufruf des Dienstes.
+ *
+ * ZWEI DINGE, DIE DIESE HUELLE NIE TUT:
+ *
+ * 1. Sie faelscht kein Ergebnis. Laeuft die Frist ab, wirft sie
+ *    `EMBEDDING_UNAVAILABLE` — nie einen leeren Vektorsatz, der weiter unten
+ *    als „fertig" durchginge (spec.md §25.1, BUILD_PLAN E4).
+ * 2. Sie taeuscht keinen Nutzerabbruch vor. Ein Fristablauf traegt bewusst
+ *    NICHT den Namen `AbortError` und nicht den Code `JOB_CANCELLED`: der
+ *    Laeufer unterscheidet Abbruch von Fehlschlag genau daran (siehe
+ *    `packages/core/src/cancellation.ts`), und ein Fristablauf ist ein
+ *    Fehlschlag der UMGEBUNG, kein Strg-C. Bricht dagegen der Nutzer wirklich
+ *    ab, geht sein Fehler unveraendert weiter.
+ */
+import { UntangleError, } from "@untangle-code/domain";
+import { withDeadline } from "./deadline.js";
+import { systemClock } from "./system.js";
+/**
+ * Vorgabefrist je Aufruf.
+ *
+ * Grosszuegiger als die 15 s von `doctor`, weil ein Indexstapel echte Arbeit
+ * ist (acht Dateien, ein kalt geladenes Modell) — und trotzdem endlich, weil
+ * genau das der Unterschied zwischen „dauert" und „haengt" ist. Wem sie zu
+ * knapp ist, der hebt sie mit `--timeout` an; wer schnell scheitern will,
+ * senkt sie.
+ */
+export const DEFAULT_EMBEDDING_TIMEOUT_MS = 60_000;
+/** Abstand der Lebenszeichen, solange ein Aufruf laeuft. */
+export const DEFAULT_HEARTBEAT_MS = 5_000;
+/**
+ * Legt {@link EmbeddingDeadlineOptions.timeoutMs} um jeden Aufruf von
+ * `inner` und meldet, dass gewartet wird.
+ */
+export function withEmbeddingDeadline(inner, options) {
+    const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+    const clock = options.clock ?? systemClock;
+    const now = () => clock.nowEpochMs();
+    async function guarded(label, startNote, call, callerOptions) {
+        options.onProgress?.(startNote);
+        // Das Signal des Aufrufers ist das aeussere, wenn es eines gibt: der
+        // Laeufer reicht sein internes Signal durch, und daran haengt Strg-C.
+        const outer = callerOptions?.signal ?? options.outerSignal;
+        const startedAt = now();
+        const timer = heartbeatMs > 0 && options.onProgress !== undefined
+            ? setInterval(() => {
+                const elapsedMs = now() - startedAt;
+                options.onProgress?.(`       … ${label}: waiting ${seconds(elapsedMs)} without a response ` +
+                    `(deadline ${seconds(options.timeoutMs)}).`);
+            }, heartbeatMs)
+            : undefined;
+        // Ein Lebenszeichen darf den Prozess nie am Leben halten.
+        timer?.unref?.();
+        let outcome;
+        try {
+            outcome = await withDeadline(call, options.timeoutMs, outer);
+        }
+        finally {
+            if (timer !== undefined)
+                clearInterval(timer);
+        }
+        if (outcome.ok)
+            return outcome.value;
+        if (!outcome.timedOut)
+            throw outcome.error;
+        throw new UntangleError("EMBEDDING_UNAVAILABLE", `The embedding service did not answer "${label}" within ${String(options.timeoutMs)} ms ` +
+            ". The call was cancelled; a cancelled call is not a " +
+            "result but a failure.", {
+            retryable: true,
+            operation: "index.embed",
+            context: { call: label, timeoutMs: options.timeoutMs, model: inner.profile.model },
+            cause: outcome.error,
+        });
+    }
+    return {
+        get profile() {
+            return inner.profile;
+        },
+        get profileId() {
+            return inner.profileId;
+        },
+        ensureReady(callerOptions) {
+            return guarded("Readiness check", `[  2%] Embedding service: readiness check running; model ${inner.profile.model}, ` +
+                `deadline ${seconds(options.timeoutMs)} per call.`, (signal) => inner.ensureReady({ signal }), callerOptions);
+        },
+        embedDocuments(preparedTexts, callerOptions) {
+            return guarded(`Embedding ${String(preparedTexts.length)} texts`, `       Embedding: ${String(preparedTexts.length)} texts in progress ` +
+                `(deadline ${seconds(options.timeoutMs)}).`, (signal) => inner.embedDocuments(preparedTexts, { signal }), callerOptions);
+        },
+        embedQuery(preparedText, callerOptions) {
+            return guarded("Query embedding", `       Query embedding in progress (deadline ${seconds(options.timeoutMs)}).`, (signal) => inner.embedQuery(preparedText, { signal }), callerOptions);
+        },
+    };
+}
+/** „61 s" statt „61000 ms" — die Frist liest ein Mensch. */
+function seconds(milliseconds) {
+    const value = milliseconds / 1000;
+    return `${Number.isInteger(value) ? String(value) : value.toFixed(1)} s`;
+}
+//# sourceMappingURL=embedder-deadline.js.map

package/dist/cli/embedder-deadline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedder-deadline.js","sourceRoot":"","sources":["../../src/cli/embedder-deadline.ts"],"names":[],"mappings":"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"}

package/dist/cli/exit.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Exit codes and the error shapes that produce them.
+ *
+ * WARUM EIGENE CODES UND NICHT NUR 0/1: Der Nutzer will Untangle in eine
+ * Schleife haengen („continuous complexity monitoring"). Eine Schleife muss
+ * „das Werkzeug kann das noch nicht" von „die Umgebung laeuft nicht" und von
+ * „die Schwelle wurde gerissen" unterscheiden koennen, ohne stderr zu parsen.
+ * Genau dafuer sind die Codes belegt.
+ *
+ * BUILD_PLAN E4 gilt auch hier: {@link EXIT.unavailable} ist ein EIGENER Code,
+ * damit eine noch nicht gebaute Faehigkeit nie wie ein Betriebsfehler aussieht
+ * — und nie wie ein Erfolg.
+ */
+export declare const EXIT: {
+    /** Alles gut. */
+    readonly ok: 0;
+    /** Betriebsfehler: Datei unlesbar, Konfiguration ungueltig, Adapter warf. */
+    readonly operational: 1;
+    /** Aufruffehler: unbekannter Befehl, unbekannte Option, fehlendes Argument. */
+    readonly usage: 2;
+    /** Die Faehigkeit ist noch nicht gebaut. Kein Fehler des Nutzers. */
+    readonly unavailable: 3;
+    /** Die Umgebung ist nicht bereit: Ollama/Qdrant nicht erreichbar, kein Index. */
+    readonly environment: 4;
+    /** Eine Schwelle wurde gerissen (Quality Gate). Die Analyse selbst lief. */
+    readonly gate: 5;
+    /** Abgebrochen (SIGINT/SIGTERM). */
+    readonly cancelled: 130;
+};
+export type ExitCode = (typeof EXIT)[keyof typeof EXIT];
+/**
+ * Ein Fehler, den die Oberflaeche selbst erzeugt hat.
+ *
+ * `nextStep` ist bewusst ein Pflichtfeld im Konstruktor jedes Untertyps, der
+ * es tragen kann: eine Fehlermeldung ohne naechsten Schritt laesst den Nutzer
+ * genau dort stehen, wo er nicht weiterkommt.
+ */
+export declare class CliError extends Error {
+    readonly exitCode: ExitCode;
+    readonly nextStep: string | undefined;
+    constructor(message: string, exitCode: ExitCode, nextStep?: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Falsch aufgerufen — unbekannter Befehl, unbekannte Option, fehlender Wert. */
+export declare class UsageError extends CliError {
+    constructor(message: string, nextStep?: string);
+}
+/** Etwas ist schiefgegangen, das schiefgehen darf. */
+export declare class OperationalError extends CliError {
+    constructor(message: string, nextStep?: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Die Faehigkeit ist noch nicht gebaut.
+ *
+ * `reason` sagt, WAS fehlt und WO es hingehoert — nicht „nicht implementiert",
+ * sondern die pruefbare Aussage. Ein Nutzer, der das liest, kann selbst
+ * nachsehen, ob es inzwischen anders ist.
+ */
+export declare class UnavailableError extends CliError {
+    constructor(message: string, nextStep: string);
+}
+/** Die Umgebung ist nicht bereit. */
+export declare class EnvironmentError extends CliError {
+    constructor(message: string, nextStep: string, options?: {
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=exit.d.ts.map

package/dist/cli/exit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.d.ts","sourceRoot":"","sources":["../../src/cli/exit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,IAAI;IACf,iBAAiB;;IAEjB,6EAA6E;;IAE7E,+EAA+E;;IAE/E,qEAAqE;;IAErE,iFAAiF;;IAEjF,4EAA4E;;IAE5E,oCAAoC;;CAE5B,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC,MAAM,OAAO,IAAI,CAAC,CAAC;AAExD;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;gBAGpC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,QAAQ,EAClB,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAOhC;AAED,iFAAiF;AACjF,qBAAa,UAAW,SAAQ,QAAQ;gBAC1B,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAI/C;AAED,sDAAsD;AACtD,qBAAa,gBAAiB,SAAQ,QAAQ;gBAChC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAI9E;AAED;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,QAAQ;gBAChC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAI9C;AAED,qCAAqC;AACrC,qBAAa,gBAAiB,SAAQ,QAAQ;gBAChC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAI7E"}

package/dist/cli/exit.js

@@ -0,0 +1,81 @@
+/**
+ * Exit codes and the error shapes that produce them.
+ *
+ * WARUM EIGENE CODES UND NICHT NUR 0/1: Der Nutzer will Untangle in eine
+ * Schleife haengen („continuous complexity monitoring"). Eine Schleife muss
+ * „das Werkzeug kann das noch nicht" von „die Umgebung laeuft nicht" und von
+ * „die Schwelle wurde gerissen" unterscheiden koennen, ohne stderr zu parsen.
+ * Genau dafuer sind die Codes belegt.
+ *
+ * BUILD_PLAN E4 gilt auch hier: {@link EXIT.unavailable} ist ein EIGENER Code,
+ * damit eine noch nicht gebaute Faehigkeit nie wie ein Betriebsfehler aussieht
+ * — und nie wie ein Erfolg.
+ */
+export const EXIT = {
+    /** Alles gut. */
+    ok: 0,
+    /** Betriebsfehler: Datei unlesbar, Konfiguration ungueltig, Adapter warf. */
+    operational: 1,
+    /** Aufruffehler: unbekannter Befehl, unbekannte Option, fehlendes Argument. */
+    usage: 2,
+    /** Die Faehigkeit ist noch nicht gebaut. Kein Fehler des Nutzers. */
+    unavailable: 3,
+    /** Die Umgebung ist nicht bereit: Ollama/Qdrant nicht erreichbar, kein Index. */
+    environment: 4,
+    /** Eine Schwelle wurde gerissen (Quality Gate). Die Analyse selbst lief. */
+    gate: 5,
+    /** Abgebrochen (SIGINT/SIGTERM). */
+    cancelled: 130,
+};
+/**
+ * Ein Fehler, den die Oberflaeche selbst erzeugt hat.
+ *
+ * `nextStep` ist bewusst ein Pflichtfeld im Konstruktor jedes Untertyps, der
+ * es tragen kann: eine Fehlermeldung ohne naechsten Schritt laesst den Nutzer
+ * genau dort stehen, wo er nicht weiterkommt.
+ */
+export class CliError extends Error {
+    exitCode;
+    nextStep;
+    constructor(message, exitCode, nextStep, options) {
+        super(message, options === undefined ? undefined : { cause: options.cause });
+        this.name = "CliError";
+        this.exitCode = exitCode;
+        this.nextStep = nextStep;
+    }
+}
+/** Falsch aufgerufen — unbekannter Befehl, unbekannte Option, fehlender Wert. */
+export class UsageError extends CliError {
+    constructor(message, nextStep) {
+        super(message, EXIT.usage, nextStep);
+        this.name = "UsageError";
+    }
+}
+/** Etwas ist schiefgegangen, das schiefgehen darf. */
+export class OperationalError extends CliError {
+    constructor(message, nextStep, options) {
+        super(message, EXIT.operational, nextStep, options);
+        this.name = "OperationalError";
+    }
+}
+/**
+ * Die Faehigkeit ist noch nicht gebaut.
+ *
+ * `reason` sagt, WAS fehlt und WO es hingehoert — nicht „nicht implementiert",
+ * sondern die pruefbare Aussage. Ein Nutzer, der das liest, kann selbst
+ * nachsehen, ob es inzwischen anders ist.
+ */
+export class UnavailableError extends CliError {
+    constructor(message, nextStep) {
+        super(message, EXIT.unavailable, nextStep);
+        this.name = "UnavailableError";
+    }
+}
+/** Die Umgebung ist nicht bereit. */
+export class EnvironmentError extends CliError {
+    constructor(message, nextStep, options) {
+        super(message, EXIT.environment, nextStep, options);
+        this.name = "EnvironmentError";
+    }
+}
+//# sourceMappingURL=exit.js.map

package/dist/cli/exit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.js","sourceRoot":"","sources":["../../src/cli/exit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,iBAAiB;IACjB,EAAE,EAAE,CAAC;IACL,6EAA6E;IAC7E,WAAW,EAAE,CAAC;IACd,+EAA+E;IAC/E,KAAK,EAAE,CAAC;IACR,qEAAqE;IACrE,WAAW,EAAE,CAAC;IACd,iFAAiF;IACjF,WAAW,EAAE,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,CAAC;IACP,oCAAoC;IACpC,SAAS,EAAE,GAAG;CACN,CAAC;AAIX;;;;;;GAMG;AACH,MAAM,OAAO,QAAS,SAAQ,KAAK;IACxB,QAAQ,CAAW;IACnB,QAAQ,CAAqB;IAEtC,YACE,OAAe,EACf,QAAkB,EAClB,QAAiB,EACjB,OAA6B;QAE7B,KAAK,CAAC,OAAO,EAAE,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC7E,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF;AAED,iFAAiF;AACjF,MAAM,OAAO,UAAW,SAAQ,QAAQ;IACtC,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;IAC3B,CAAC;CACF;AAED,sDAAsD;AACtD,MAAM,OAAO,gBAAiB,SAAQ,QAAQ;IAC5C,YAAY,OAAe,EAAE,QAAiB,EAAE,OAA6B;QAC3E,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,OAAO,gBAAiB,SAAQ,QAAQ;IAC5C,YAAY,OAAe,EAAE,QAAgB;QAC3C,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AAED,qCAAqC;AACrC,MAAM,OAAO,gBAAiB,SAAQ,QAAQ;IAC5C,YAAY,OAAe,EAAE,QAAgB,EAAE,OAA6B;QAC1E,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF"}

package/dist/cli/graphs.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Der LESEWEG zu den beiden Graphen — die Stelle, die `untangle graph` und
+ * `untangle flow` bisher gefehlt hat.
+ *
+ * `untangle index` baut Datei- und Symbolgraph und legt sie ueber den
+ * `GraphStore`-Port workspace- und generationsgebunden ab. Der zuletzt
+ * geschriebene, namespacete Symbolsnapshot ist zugleich der Publish-Marker
+ * fuer das zusammengehoerige Graphpaar. Dieses Modul holt beide zurueck.
+ *
+ * DREI ENTSCHEIDUNGEN:
+ *
+ * 1. DIE GENERATION WIRD NICHT GERATEN. Gelesen wird der workspace-spezifische
+ *    Publish-Marker. Seine validierte `generationId` ist danach die Generation
+ *    ALLER weiteren Lesevorgaenge — sonst mischte eine Abfrage Knoten aus zwei
+ *    Laeufen, und niemand saehe es.
+ *
+ * 2. EIN LOECHRIGES ABBILD WIRD GEMELDET, NICHT GEGLAETTET. `readGraphSnapshot`
+ *    gibt seine Befunde als Daten zurueck (fehlender Datei-Shard, fehlender
+ *    Pfadindex, Zahlen, die nicht zusammenpassen). Sie landen in
+ *    {@link LoadedGraphsV1.issues} und gehen auf stderr — ein Graph, dem
+ *    unbemerkt Knoten fehlen, ist schlimmer als gar keiner (E4).
+ *
+ * 3. „KEIN INDEX" IST NICHT „KEIN ERGEBNIS". Fehlt der Graph, endet der Befehl
+ *    mit Exit-Code 4 und dem naechsten Schritt — nie mit einer leeren Liste
+ *    und Exit-Code 0. Das ist derselbe Fehler, der in Welle 4 in `query`
+ *    gefunden wurde.
+ */
+import { type RestoredFileGraph, type SnapshotReadIssue } from "@untangle-code/file-graph";
+import { type SymbolGraphV1 } from "@untangle-code/symbol-graph";
+import { type WorkspaceView } from "./workspace.js";
+/**
+ * Der Symbolgraph, wie er aus dem Shard zurueckkommt — samt expliziter Angabe,
+ * ob sein Skip-Ledger aus demselben Snapshot stammt.
+ *
+ * Das aktuelle persistierte Format schreibt den vollständigen Symbolsnapshot
+ * einschließlich Ledger und liefert deshalb `ledgerInShard: true`. Das Feld
+ * bleibt im Vertrag sichtbar: ein zukünftiger Kompatibilitätspfad darf ein
+ * fehlendes Ledger nicht als nachgewiesen leeres Ledger ausgeben (E4).
+ */
+export interface LoadedSymbolGraphV1 {
+    graph: SymbolGraphV1;
+    ledgerInShard: boolean;
+}
+export interface LoadedGraphsV1 {
+    view: WorkspaceView;
+    /** Generation, aus der ALLE gelesenen Shards stammen. */
+    generationId: string;
+    fileGraph: RestoredFileGraph;
+    /** Befunde des Zurueckladens; leer heisst vollstaendig. */
+    issues: readonly SnapshotReadIssue[];
+    /** Null, wenn `untangle index` keinen Symbolgraphen abgelegt hat. */
+    symbolGraph: LoadedSymbolGraphV1 | null;
+    /** Pflicht, wenn `symbolGraph` null ist (E4). */
+    symbolGraphMissingReason?: string;
+}
+export interface LoadGraphsOptions {
+    cwd: string;
+    env: Readonly<Record<string, string | undefined>>;
+    signal: AbortSignal;
+    /** Projektverzeichnis aus `--root`, bereits aufgeloest. */
+    root?: string | undefined;
+}
+/** Laedt Datei- und Symbolgraph der neuesten vollstaendigen Generation. */
+export declare function loadGraphs(options: LoadGraphsOptions): Promise<LoadedGraphsV1>;
+//# sourceMappingURL=graphs.d.ts.map

package/dist/cli/graphs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphs.d.ts","sourceRoot":"","sources":["../../src/cli/graphs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACvB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE9F;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,aAAa,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,2DAA2D;IAC3D,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrC,qEAAqE;IACrE,WAAW,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACxC,iDAAiD;IACjD,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAClD,MAAM,EAAE,WAAW,CAAC;IACpB,2DAA2D;IAC3D,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,2EAA2E;AAC3E,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAsCpF"}

package/dist/cli/graphs.js

@@ -0,0 +1,108 @@
+/**
+ * Der LESEWEG zu den beiden Graphen — die Stelle, die `untangle graph` und
+ * `untangle flow` bisher gefehlt hat.
+ *
+ * `untangle index` baut Datei- und Symbolgraph und legt sie ueber den
+ * `GraphStore`-Port workspace- und generationsgebunden ab. Der zuletzt
+ * geschriebene, namespacete Symbolsnapshot ist zugleich der Publish-Marker
+ * fuer das zusammengehoerige Graphpaar. Dieses Modul holt beide zurueck.
+ *
+ * DREI ENTSCHEIDUNGEN:
+ *
+ * 1. DIE GENERATION WIRD NICHT GERATEN. Gelesen wird der workspace-spezifische
+ *    Publish-Marker. Seine validierte `generationId` ist danach die Generation
+ *    ALLER weiteren Lesevorgaenge — sonst mischte eine Abfrage Knoten aus zwei
+ *    Laeufen, und niemand saehe es.
+ *
+ * 2. EIN LOECHRIGES ABBILD WIRD GEMELDET, NICHT GEGLAETTET. `readGraphSnapshot`
+ *    gibt seine Befunde als Daten zurueck (fehlender Datei-Shard, fehlender
+ *    Pfadindex, Zahlen, die nicht zusammenpassen). Sie landen in
+ *    {@link LoadedGraphsV1.issues} und gehen auf stderr — ein Graph, dem
+ *    unbemerkt Knoten fehlen, ist schlimmer als gar keiner (E4).
+ *
+ * 3. „KEIN INDEX" IST NICHT „KEIN ERGEBNIS". Fehlt der Graph, endet der Befehl
+ *    mit Exit-Code 4 und dem naechsten Schritt — nie mit einer leeren Liste
+ *    und Exit-Code 0. Das ist derselbe Fehler, der in Welle 4 in `query`
+ *    gefunden wurde.
+ */
+import { readGraphSnapshot, restoreFileGraph, } from "@untangle-code/file-graph";
+import { readSymbolGraphSnapshot, symbolGraphSnapshotShardId, } from "@untangle-code/symbol-graph";
+import { EnvironmentError, OperationalError } from "./exit.js";
+import { errorMessage, loadWorkspace, wireStorage } from "./workspace.js";
+/** Laedt Datei- und Symbolgraph der neuesten vollstaendigen Generation. */
+export async function loadGraphs(options) {
+    const view = loadWorkspace({
+        cwd: options.root ?? options.cwd,
+        env: options.env,
+        strict: true,
+    });
+    const storage = wireStorage(view, options.env);
+    const store = storage.storage.graphStore;
+    const generationId = await readPublishedGeneration(store, view.workspaceId, options.signal, storage.storeUrl);
+    const scope = { workspaceId: view.workspaceId, generationId };
+    const { snapshot, issues } = await readGraphSnapshot(store, scope, { signal: options.signal });
+    if (snapshot === null) {
+        throw new EnvironmentError(`Could not reload file-graph generation "${generationId}": ` +
+            issues.map((issue) => `${issue.kind}: ${issue.message}`).join("; "), "Rebuild the index with `untangle index`. Nothing was evaluated; this is not the same as an empty graph.");
+    }
+    const symbol = await readSymbolGraph(store, scope, options.signal);
+    return {
+        view,
+        generationId,
+        fileGraph: restoreFileGraph(snapshot),
+        issues,
+        symbolGraph: symbol.graph,
+        ...(symbol.missingReason === undefined
+            ? {}
+            : { symbolGraphMissingReason: symbol.missingReason }),
+    };
+}
+async function readPublishedGeneration(store, workspaceId, signal, storeUrl) {
+    let shard;
+    try {
+        // Der namespacete Symbolgraph wird NACH dem Dateigraphen geschrieben und
+        // ist damit der Publish-Marker des zusammengehoerigen Graphpaares. Ein
+        // abgebrochener neuer Dateigraph kann diese Auswahl nicht verschieben.
+        shard = await store.readShard("graph_meta", symbolGraphSnapshotShardId(workspaceId), {
+            signal,
+        });
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        throw new EnvironmentError(`The graph store at ${storeUrl} could not be read: ${errorMessage(error)}`, "Check the vector store with `untangle doctor`, then run `untangle index`.", { cause: error });
+    }
+    if (shard === null) {
+        throw new EnvironmentError(`In ${storeUrl} has no published graph pair for workspace "${workspaceId}". ` +
+            `Nothing was evaluated; this does not ` +
+            "mean there are no dependencies.", "Run `untangle index` to build and store file and symbol graphs.");
+    }
+    if (shard.generationId === "") {
+        throw new OperationalError("The workspace-graph publish shard has no generation.", "Rebuild the index with `untangle index`.");
+    }
+    if (shard.payload["workspaceId"] !== workspaceId ||
+        shard.payload["graphGeneration"] !== shard.generationId) {
+        throw new OperationalError("The workspace-graph publish shard conflicts with its workspace or generation scope.", "Rebuild the index with `untangle index`.");
+    }
+    return shard.generationId;
+}
+async function readSymbolGraph(store, scope, signal) {
+    let result;
+    try {
+        result = await readSymbolGraphSnapshot(store, scope, { signal });
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        return {
+            graph: null,
+            missingReason: `Could not read the symbol graph: ${errorMessage(error)}`,
+        };
+    }
+    if (result.snapshot === null) {
+        return {
+            graph: null,
+            missingReason: result.issues.map((issue) => `${issue.kind}: ${issue.message}`).join("; "),
+        };
+    }
+    return { graph: { graph: result.snapshot, ledgerInShard: true } };
+}
+//# sourceMappingURL=graphs.js.map

package/dist/cli/graphs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphs.js","sourceRoot":"","sources":["../../src/cli/graphs.ts"],"names":[],"mappings":"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"}

package/dist/cli/index-freshness.d.ts

@@ -0,0 +1,13 @@
+import { type IndexFreshnessV1, type PortCallOptions } from "@untangle-code/domain";
+import { type ResolvedTarget } from "../commands/index/target.js";
+import type { FoundIndexState } from "./index-state.js";
+import type { WorkspaceView } from "./workspace.js";
+type FreshnessOptions = PortCallOptions & {
+    expectedRepoIds?: readonly string[];
+    expectedRefs?: readonly string[];
+};
+/** Bind source selection and chunk semantics; operational concurrency does not change the corpus. */
+export declare function indexConfigFingerprint(view: WorkspaceView, target: ResolvedTarget): string;
+export declare function inspectIndexFreshness(view: WorkspaceView, states: readonly FoundIndexState[], options?: FreshnessOptions): Promise<IndexFreshnessV1>;
+export {};
+//# sourceMappingURL=index-freshness.d.ts.map

package/dist/cli/index-freshness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-freshness.d.ts","sourceRoot":"","sources":["../../src/cli/index-freshness.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAEhG,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,kBAAkB,CAAC;AACtE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD,KAAK,gBAAgB,GAAG,eAAe,GAAG;IACxC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,qGAAqG;AACrG,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,CAc1F;AAED,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,SAAS,eAAe,EAAE,EAClC,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,gBAAgB,CAAC,CAY3B"}