Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

12.5 KB
Raw Blame
import { mountTemplate } from "./shared.ts";
import { saveButton, settingStatus, saveFooter } from "./setting-controls.ts";
import { SettingState, settingRegistry } from "./setting-state.ts";
import { mountCredentials } from "./settings-credentials.ts";
export {
  configureCredentials,
  credentialState,
  credentialStatus,
  credentialLoading,
  loadCredentials,
  keychainSummary,
} from "./settings-credentials.ts";
import { mountProviders } from "./settings-providers.ts";
export { configureProviders, openProvider, loadProviders } from "./settings-providers.ts";
import { mountFlags } from "./settings-flags.ts";
import { mountDecisions } from "./settings-decisions.ts";
export { configureFlags, loadFlags } from "./settings-flags.ts";
export { configureDecisions, loadDecisions } from "./settings-decisions.ts";
import { brandingCard } from "./settings-branding.ts";
import { mountRuntimes } from "./settings-runtimes.ts";
export { configureRuntimes } from "./settings-runtimes.ts";
import { html } from "lit";
import { classMap } from "lit/directives/class-map.js";
import { repeat } from "lit/directives/repeat.js";

type Model = { id: string; name?: string };
type Data = Record<string, any>;
const runtimeKeys = ["runtime", "cron-runtime", "subagent-runtime", "fallback-runtime"];
const runtimeReadKey = (key: string) => key.replace(/-runtime$/, "Runtime");
export class SettingsState extends SettingState {
  context: Data = {};
  selected = "";
  editing = false;
  history: Data[] = [];
  collect(_validate = true): Data {
    if (_validate && this.key === "soul" && (this.draft.content || "").length > 100000)
      throw new Error("Maximum length reached");
    if (this.key !== "runtime" && runtimeKeys.includes(this.key)) {
      if (this.draft.inherit) return { inherit: true };
      const { inherit: _inherit, ...selection } = this.draft;
      return structuredClone(selection);
    }
    if (this.key === "memory-embedding-model") return { modelId: this.draft.modelId || null };
    if (this.key === "branding")
      return Object.fromEntries(Object.entries(this.draft).map(([key, value]) => [key, String(value).trim()]));
    return structuredClone(this.draft);
  }
  get catalog(): Model[] {
    return [
      ...Object.values(this.context.modelsByHarness || {}).flat(),
      ...(this.context.baseModelOptions || []),
    ].filter((m: any, i, all) => m?.id && all.findIndex((x: any) => x?.id === m.id) === i) as Model[];
  }
  change(field: string, value: unknown) {
    this.draft[field] = value;
    this.changed();
  }
  changed() {
    this.message = this.dirty ? "Unsaved changes" : "";
    this.tone = "";
    this.render();
  }
  commit(body: Data) {
    this.baseline = JSON.stringify(body);
    this.saving = false;
    this.changed();
  }
  add() {
    if (this.selected && !this.draft.ids.includes(this.selected)) this.draft.ids.push(this.selected);
    this.selected = "";
    this.changed();
  }
  remove(id: string) {
    this.draft.ids = this.draft.ids.filter((x: string) => x !== id);
    this.changed();
  }
}
export const states = new Map(
  [...runtimeKeys, "webui-models", "memory-embedding-model", "soul", "branding"].map((key) => [
    key,
    new SettingsState(key),
  ]),
);
export const { owns, collect, capture, commit, status, statusKey } = settingRegistry(states);
export function load(data: Data, scope: string, only?: string) {
  for (const [key, s] of states) {
    if (only && only !== key) continue;
    s.context = data;
    if (key === "branding") {
      s.draft = {
        accent: data.branding?.accent || "",
        mark: data.branding?.mark || "",
        selfLabel: data.branding?.selfLabel || "",
        orgName: data.branding?.orgName || "",
        markUrl: data.branding?.markUrl || "",
      };
      s.available = scope.startsWith("org:") && "branding" in data;
      s.saving = false;
      capture(key);
      continue;
    }
    if (key === "memory-embedding-model") {
      s.draft = { modelId: data.memoryEmbeddingModel || "" };
      s.available = scope.startsWith("org:") && "memoryEmbeddingModel" in data;
      s.saving = false;
      capture(key);
      continue;
    }
    if (key === "soul") {
      s.draft = { content: data.soul || "", expectedVersion: data.soulVersion || 0 };
      s.history = data.soulHistory || [];
      s.editing = false;
      s.available = true;
      s.saving = false;
      capture(key);
      continue;
    }
    s.available =
      scope.startsWith("org:") &&
      !!data.baseModelOptions?.length &&
      (!runtimeKeys.includes(key) || (!!data.baseModelDefault && runtimeReadKey(key) in data));
    const runtime = data[runtimeReadKey(key)];
    s.draft = runtimeKeys.includes(key)
      ? {
          ...(key !== "runtime" ? { inherit: !runtime } : {}),
          harnessId: runtime?.harnessId || data.harnessDefault || "pi",
          modelId: runtime?.modelId || data.baseModel || data.baseModelDefault || "",
          effortLevel: runtime?.effortLevel || "auto",
          fastMode: runtime?.fastMode === true,
        }
      : { ids: (data.webuiModels || []).filter(Boolean) };
    s.saving = false;
    s.selected = "";
    capture(key);
  }
}
export function updateCatalog(data: Data) {
  for (const s of states.values()) {
    s.context = { ...s.context, ...data };
    s.render();
  }
}
const value = (event: Event) => (event.target as HTMLInputElement).value;
const label = (s: SettingsState, id: string) => {
  const m = s.catalog.find((x) => x.id === id);
  return m?.name && m.name !== id ? `${m.name} (${id})` : id;
};
function card(s: SettingsState) {
  if (s.key === "soul") return soulCard(s);
  if (s.key === "branding") return brandingCard(s);
  const ids: string[] = s.draft.ids || [];
  const available = s.catalog.filter((m) => !ids.includes(m.id));
  const canAdd = available.some((m) => m.id === s.selected);
  return html`<section
    class=${classMap({ card: true, "sv-models": true, hidden: !s.available, dirty: s.dirty })}
    id="card-webui-models"
  >
    <div class="head"><h2>Enabled models</h2></div>
    <div class="body">
      <div class="model-add-row">
        <div class="model-add-field">
          <label for="webui-models-add">Add a model</label
          ><input
            id="webui-models-add"
            list="webui-models-options"
            autocomplete="off"
            placeholder="Search models…"
            .value=${s.selected}
            ?disabled=${!available.length}
            @input=${(e: Event) => {
              s.selected = value(e);
              s.render();
            }}
            @keydown=${(e: KeyboardEvent) => e.key === "Enter" && canAdd && s.add()}
          /><datalist id="webui-models-options">
            ${available.map((m) => html`<option value=${m.id}>${label(s, m.id)}</option>`)}
          </datalist>
        </div>
        <button type="button" id="webui-models-add-button" ?disabled=${!canAdd} @click=${() => s.add()}>
          + Add model
        </button>
      </div>
      <div id="webui-models-list" class="model-list">
        <p id="webui-models-empty" class=${classMap({ hint: true, hidden: !!ids.length })}>
          No additional models enabled.
        </p>
        ${repeat(
          ids,
          (id) => id,
          (id) =>
            html`<span data-chip=${id} class="model-chip"
              ><span>${label(s, id)}</span
              ><button type="button" aria-label=${"Remove " + id} @click=${() => s.remove(id)}>
                <svg
                  width="12"
                  height="12"
                  viewBox="0 0 16 16"
                  fill="none"
                  stroke="currentColor"
                  stroke-width="1.5"
                  stroke-linecap="round"
                  aria-hidden="true"
                >
                  <path d="m4 4 8 8M12 4l-8 8" />
                </svg></button
            ></span>`,
        )}
      </div>
    </div>
    ${saveFooter(s)}
  </section>`;
}
export function mountCards() {
  mountFlags();
  mountDecisions();
  mountProviders();
  mountCredentials();
  mountRuntimes();
  for (const [key, s] of states) {
    const id = (
      { soul: "card-soul", branding: "card-branding", "webui-models": "card-webui-models" } as Record<string, string>
    )[key];
    if (id) s.render = mountTemplate(`template[data-settings-card="${id}"]`, () => card(s));
  }
}

let soulActions: { formatTime: (time: any) => string; restore: (revision: Data) => Promise<void> } = {
  formatTime: String,
  restore: async () => {},
};
export function configureSoul(actions: typeof soulActions) {
  soulActions = actions;
}
export function refreshSoul(data: Data) {
  const s = states.get("soul")!;
  s.draft.expectedVersion = data.soulVersion || 0;
  s.baseline = JSON.stringify({ content: data.soul || "", expectedVersion: s.draft.expectedVersion });
  s.history = data.soulHistory || [];
  s.changed();
}
function soulCard(s: SettingsState) {
  const saved = JSON.parse(s.baseline).content || "";
  const content = s.draft.content || "";
  return html`<section
    class=${classMap({ card: true, "sv-customize": true, "is-editing": s.editing, dirty: s.dirty })}
    id="card-soul"
  >
    <div class="head">
      <h2>Organization SOUL</h2>
      <p>
        Write the standing instructions composed into every system prompt for this scope. Saving creates a durable
        revision; restoring an older revision creates a new one.
      </p>
    </div>
    <div class="body soul-preview-body">
      <div class="soul-preview-label" id="soul-preview-label">Standing instructions</div>
      <p class="soul-preview" id="soul-preview" aria-labelledby="soul-preview-label">
        ${saved || "No saved instructions"}
      </p>
    </div>
    <div class="body soul-workbench">
      <label for="soul">Standing instructions</label
      ><textarea
        id="soul"
        maxlength="100000"
        placeholder="No scope-specific instructions"
        .value=${content}
        @input=${(e: Event) => s.change("content", value(e))}
      ></textarea>
      <div class="soul-meta">
        <span id="soul-ver"
          >${s.draft.expectedVersion ? "Saved version " + s.draft.expectedVersion : "No saved revision"}</span
        ><span id="soul-size"
          >${content.length.toLocaleString() + " characters · about " + Math.ceil(content.length / 4).toLocaleString() + " tokens"}</span
        ><span id="soul-validation">${content.length >= 100000 ? "Maximum length reached" : "Draft valid"}</span>
      </div>
      <div class="soul-diff" id="soul-diff">
        <section>
          <h3>Saved revision</h3>
          <pre id="soul-saved">${saved || "No saved instructions"}</pre>
        </section>
        <section>
          <h3>Current draft</h3>
          <pre id="soul-draft">
${content === saved ? "No draft changes" : content || "Instructions will be cleared"}</pre>
        </section>
      </div>
      <div class="soul-history" id="soul-history" aria-label="SOUL version history">
        <h3>Version history</h3>
        ${
          s.history.length
            ? repeat(
                s.history,
                (r) => r.version,
                (r) =>
                  html`<div class="soul-revision">
                    <p>
                      Version ${r.version}<small
                        >${r.updatedBy || "Author unavailable"} ·
                        ${r.updatedAt ? soulActions.formatTime(r.updatedAt) : "Time unavailable"}</small
                      >
                    </p>
                    <button
                      type="button"
                      ?disabled=${r.version === s.draft.expectedVersion || s.saving}
                      @click=${() => soulActions.restore({ ...r })}
                    >
                      ${r.version === s.draft.expectedVersion ? "Current" : "Restore"}
                    </button>
                  </div>`,
              )
            : html`<p class="hint">History begins with the next saved revision.</p>`
        }
      </div>
    </div>
    <div class="foot">
      <button
        type="button"
        class="viewlink"
        id="soul-history-link"
        @click=${() => {
          s.editing = true;
          s.render();
          document.getElementById("soul-history")?.scrollIntoView({ behavior: "smooth", block: "center" });
        }}
      >
        View history ›</button
      ><button
        type="button"
        id="soul-edit"
        @click=${() => {
          s.editing = !s.editing;
          if (!s.editing) s.draft.content = saved;
          s.changed();
          if (s.editing) document.getElementById("soul")?.focus();
        }}
      >
        ${s.editing ? "Cancel" : "Edit"}</button
      >${saveButton(s, "Save")}${settingStatus(s)}
    </div>
  </section>`;
}