@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

package/vendor/tui/lib/permissions.mjs

@@ -0,0 +1,45 @@
+/** Permission-preset policy for pending and active TUI sessions. */
+/** Read the optional Harness service without importing its runtime package. */
+export function permissionPresetsFrom(ctx) {
+    return ctx.get('permissionPresets');
+}
+/** Effective label for either an active session or the not-yet-created first one. */
+export function effectivePermission(service, session, pending) {
+    return session === undefined ? pending ?? service.defaultPreset : service.current(session);
+}
+/** Validate a preset and write it only when a durable session already exists. */
+export function selectPermission(service, session, preset) {
+    service.resolve(preset);
+    if (session !== undefined)
+        service.set(session, preset);
+    return preset;
+}
+/** Cycle table order from the active, pending, or configured-default value. */
+export function cyclePermission(service, session, pending) {
+    if (service.names.length === 0)
+        return '';
+    const at = service.names.indexOf(effectivePermission(service, session, pending));
+    const next = service.names[(at + 1) % service.names.length] ?? '';
+    return next === '' ? '' : selectPermission(service, session, next);
+}
+/** Materialize a pre-session choice after Harness creates the first session. */
+export function applyPendingPermission(service, session, pending) {
+    if (pending !== undefined && effectivePermission(service, session, undefined) !== pending) {
+        selectPermission(service, session, pending);
+    }
+}
+/**
+ * List every switchable preset for the /permission panel, table order kept.
+ * Description lookup failures degrade to an undocumented row, never a failed
+ * panel load — `optionOf` rejects names its table no longer knows.
+ */
+export function listPermissionRows(service) {
+    return service.names.map((id) => {
+        try {
+            return { id, description: service.optionOf(id)?.description };
+        }
+        catch {
+            return { id };
+        }
+    });
+}

package/vendor/tui/lib/plugin-inventory.mjs

@@ -0,0 +1,27 @@
+/** Read-only projection of Cordis Loader entries for /plugin. */
+const PHASES = {
+    0: 'pending',
+    1: 'loading',
+    2: 'active',
+    3: 'failed',
+    4: null,
+    5: 'unloading',
+};
+/** Snapshot the live Loader; group-only rows are composition containers, not plugins. */
+export function listPluginRows(ctx) {
+    const loader = ctx.get('loader');
+    if (loader === undefined)
+        return [];
+    const rows = [];
+    for (const entry of loader.entries()) {
+        if (entry.options.group === true)
+            continue;
+        rows.push({
+            entryId: entry.id,
+            moduleName: entry.options.name,
+            enabled: !entry.disabled,
+            phase: entry.fiber === undefined ? null : PHASES[entry.fiber.state] ?? null,
+        });
+    }
+    return rows;
+}

package/vendor/tui/lib/presets.mjs

@@ -0,0 +1,46 @@
+/** Agent-preset policy kept independent from the Ink surface. */
+/** Read an optional Cordis service without requiring its package at build time. */
+export function agentPresetsFrom(ctx) {
+    return ctx.get('agentPresets');
+}
+/** A preset may change only before the first durable turn begins. */
+export function isBlankSession(events) {
+    return !events.some(event => event.type === 'turn/start');
+}
+/** Upstream renamed the shipped `code` preset to `ptc` in 0.1.2-rc.1; sessions
+ * and CLI choices recorded before the rename keep resolving through this map. */
+const LEGACY_PRESET_IDS = { code: 'ptc' };
+export function normalizePresetId(id) {
+    return id === undefined ? undefined : LEGACY_PRESET_IDS[id] ?? id;
+}
+/** Latest logged selection wins; legacy sessions deliberately fall back to standard. */
+export function resolvePreset(session) {
+    const events = session.snapshotEvents();
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === 'agent-preset/selected' && event.data?.agentPreset !== undefined) {
+            return normalizePresetId(event.data.agentPreset);
+        }
+    }
+    return normalizePresetId(session.header.agentPreset) ?? 'standard';
+}
+/** Resolve a pre-session choice, or recompose an active blank Agent. */
+export async function selectPreset(service, agent, presetId) {
+    presetId = normalizePresetId(presetId);
+    if (agent !== undefined)
+        return switchPreset(service, agent, presetId);
+    const preset = await service.resolve(presetId);
+    if (preset.broken !== undefined)
+        throw new Error(preset.broken);
+    return preset;
+}
+/** Recompose atomically from the caller's perspective, logging only success. */
+export async function switchPreset(service, agent, presetId) {
+    if (!isBlankSession(agent.session.snapshotEvents())) {
+        throw new Error('mode is locked after the first turn; use /new <mode>');
+    }
+    const preset = await service.recompose(agent.ctx, presetId);
+    const writable = agent.session;
+    writable.append('agent-preset/selected', { agentPreset: preset.id });
+    return preset;
+}