@homeostat/dashboard 0.0.0-stage → 0.1.1

package/dist/src/settings.js

@@ -0,0 +1,397 @@
+import { DEFAULT_AGENT_MODEL, DEFAULT_WEIGHTS, EXPORT_TARGETS, parseConfig, } from "@homeostat/core";
+import { isMap, parseDocument } from "yaml";
+const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+const agentFields = (agent, label) => [
+    { path: ["agents", agent, "enabled"], label: `${label}: enabled`, kind: "checkbox" },
+    {
+        path: ["agents", agent, "schedule"],
+        label: `${label}: schedule`,
+        kind: "text",
+        help: "Five-field cron, UTC",
+    },
+    {
+        path: ["agents", agent, "model"],
+        label: `${label}: model`,
+        kind: "text",
+        help: `Claude model id, e.g. ${DEFAULT_AGENT_MODEL}`,
+    },
+    {
+        path: ["agents", agent, "effort"],
+        label: `${label}: effort`,
+        kind: "select",
+        options: EFFORTS,
+    },
+    {
+        path: ["agents", agent, "lookbackHours"],
+        label: `${label}: look back (hours)`,
+        kind: "number",
+    },
+];
+/** Every section of homeostat.yaml, so every key is editable without touching YAML (4.2). */
+export const SECTIONS = [
+    {
+        id: "team",
+        title: "Team and members",
+        intro: "Who contributes and reviews. Seniors own the config and areas nobody claims; handles feed CODEOWNERS.",
+        rows: "team",
+    },
+    {
+        id: "areas",
+        title: "Areas",
+        intro: "Parts of your code repos, as path globs. Core is implicit and applies everywhere.",
+        rows: "areas",
+    },
+    {
+        id: "teams",
+        title: "Teams",
+        intro: "Which team owns which areas: it approves their rules and documents. Every session still reads every team's rules for the files it touches.",
+        rows: "teams",
+    },
+    {
+        id: "sources",
+        title: "Repos and sources",
+        intro: "Where the curator reads merged pull requests, and the knowledge-base repo it opens PRs on.",
+        fields: [
+            {
+                path: ["sources", "host"],
+                label: "Git host",
+                kind: "select",
+                options: ["", "bitbucket", "github"],
+                help: "Empty removes the section",
+            },
+            {
+                path: ["sources", "kbRepo"],
+                label: "Knowledge-base repo",
+                kind: "text",
+                help: "owner/name",
+            },
+            { path: ["sources", "baseBranch"], label: "Base branch", kind: "text" },
+            {
+                path: ["sources", "repos"],
+                label: "Code repos",
+                kind: "lines",
+                help: "One owner/name per line",
+            },
+            {
+                path: ["sources", "exclude", "repos"],
+                label: "Never read these repos",
+                kind: "lines",
+                help: "One owner/name per line",
+            },
+            {
+                path: ["sources", "exclude", "paths"],
+                label: "Never read comments on these files",
+                kind: "lines",
+                help: "One glob per line, e.g. **/secrets/**",
+            },
+        ],
+    },
+    {
+        id: "scoring",
+        title: "Scoring rules",
+        intro: "Points per signal and the threshold at which a curator's entry is accepted without a reviewer.",
+        fields: [
+            ...Object.keys(DEFAULT_WEIGHTS).map((k) => ({ path: ["scoring", "weights", k], label: `Weight: ${k}`, kind: "number" })),
+            { path: ["scoring", "autoMergeThreshold"], label: "Auto-merge threshold", kind: "number" },
+            { path: ["scoring", "confidence", "accept"], label: "Merge at confidence", kind: "number" },
+            {
+                path: ["scoring", "confidence", "coreAccept"],
+                label: "Merge at confidence (core or global rules)",
+                kind: "number",
+            },
+            {
+                path: ["scoring", "confidence", "decline"],
+                label: "Decline below confidence",
+                kind: "number",
+            },
+            ...[
+                ["base", ["prFeedbackChangedCode", "prFeedback", "manual", "agentHandoff", "deepDive"]],
+                ["roles", ["junior", "member", "senior", "lead"]],
+                ["bonus", ["areaOwner", "specific", "goodTitle", "repeat", "modelRating"]],
+                ["penalty", ["vagueTitle", "conflict", "flag"]],
+            ].flatMap(([group, keys]) => keys.map((k) => ({
+                path: ["scoring", "confidence", group, k],
+                label: `Confidence ${group}: ${k}`,
+                kind: "number",
+            }))),
+            { path: ["scoring", "autoMerge", "enabled"], label: "Auto-merge", kind: "checkbox" },
+            {
+                path: ["scoring", "autoMerge", "areas"],
+                label: "Auto-merge areas",
+                kind: "lines",
+                help: "One per line; empty means every area",
+            },
+            {
+                path: ["scoring", "autoMerge", "excludeAreas"],
+                label: "Areas that always need a reviewer",
+                kind: "lines",
+                help: "One per line, e.g. core",
+            },
+            { path: ["scoring", "autoMerge", "maxPerRun"], label: "Auto-merges per run", kind: "number" },
+            {
+                path: ["scoring", "reviewCadence"],
+                label: "Review cadence",
+                kind: "select",
+                options: ["daily", "weekly", "biweekly"],
+            },
+        ],
+    },
+    {
+        id: "agents",
+        title: "Agent schedules",
+        intro: "How the agents reach Claude, when they run, and with which model.",
+        fields: [
+            {
+                path: ["agents", "runtime"],
+                label: "Claude runtime",
+                kind: "select",
+                options: ["api", "claude-code", "bedrock", "vertex"],
+                help: "api: Console key. claude-code: a Claude Code login (personal use, or a Team/Enterprise plan). bedrock / vertex: your own AWS or Google Cloud account",
+            },
+            {
+                path: ["agents", "bedrock", "region"],
+                label: "Bedrock region",
+                kind: "text",
+                optional: true,
+                help: "e.g. eu-west-1; empty uses AWS_REGION",
+            },
+            {
+                path: ["agents", "vertex", "projectId"],
+                label: "Vertex project",
+                kind: "text",
+                optional: true,
+                help: "Google Cloud project id",
+            },
+            {
+                path: ["agents", "vertex", "region"],
+                label: "Vertex region",
+                kind: "text",
+                optional: true,
+                help: "global, us, eu or a region",
+            },
+            ...agentFields("curator", "Daily run (curator)"),
+            ...agentFields("deepDive", "Deep dive"),
+            {
+                path: ["agents", "deepDive", "staleAfterDays"],
+                label: "Deep dive: retire after (days unconfirmed)",
+                kind: "number",
+            },
+            { path: ["agents", "handoff", "enabled"], label: "Handoff notes: enabled", kind: "checkbox" },
+            {
+                path: ["agents", "handoff", "minEdits"],
+                label: "Handoff notes: edits before asking",
+                kind: "number",
+            },
+        ],
+    },
+    {
+        id: "distribution",
+        title: "Distribution",
+        intro: "Which agents receive the rules as files, and how much context each session gets.",
+        fields: [
+            {
+                path: ["distribution", "exports"],
+                label: "Export targets",
+                kind: "checks",
+                options: EXPORT_TARGETS,
+            },
+            { path: ["distribution", "tokenBudget"], label: "Token budget per session", kind: "number" },
+            {
+                path: ["distribution", "docTokenBudget"],
+                label: "Token budget for documents",
+                kind: "number",
+            },
+        ],
+    },
+    {
+        id: "notifications",
+        title: "Notifications",
+        intro: "The weekly digest. The webhook URL stays in your CI secrets; only its variable name lives here.",
+        fields: [
+            {
+                path: ["notifications", "slackWebhookEnv"],
+                label: "Slack webhook variable",
+                kind: "text",
+                optional: true,
+                help: "e.g. HOMEOSTAT_SLACK_WEBHOOK",
+            },
+            {
+                path: ["notifications", "digestDay"],
+                label: "Digest day",
+                kind: "select",
+                options: ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"],
+            },
+        ],
+    },
+    {
+        id: "security",
+        title: "Security",
+        intro: "Domains rules may link to. Any other URL in a rule fails validation until a member signs the entry off; the git host is always allowed.",
+        fields: [
+            {
+                path: ["security", "allowedDomains"],
+                label: "Allowed domains",
+                kind: "lines",
+                help: "One domain per line, e.g. docs.example.com",
+            },
+            {
+                path: ["security", "teamOnlyAreas"],
+                label: "Team-only areas",
+                kind: "lines",
+                help: "Never exported; only their members' sessions see them",
+            },
+            {
+                path: ["security", "mcpWrites"],
+                label: "Let agents save and flag through MCP",
+                kind: "checkbox",
+            },
+            { path: ["security", "mcpWriteLimit"], label: "MCP writes per session", kind: "number" },
+            {
+                path: ["security", "eventRetentionDays"],
+                label: "Keep local events for (days)",
+                kind: "number",
+            },
+        ],
+    },
+];
+/** The current value of a field, from the parsed (defaulted) config. */
+export function currentValue(config, field) {
+    let v = config;
+    for (const k of field.path)
+        v = v?.[k];
+    return v;
+}
+const lines = (s) => s
+    .split(/[\n,]/)
+    .map((x) => x.trim())
+    .filter(Boolean);
+/**
+ * Applies one submitted section to the YAML text, keeping comments and untouched keys, and
+ * validates the result. Returns the new text only when it is valid.
+ */
+export function applySection(yamlText, sectionId, form) {
+    const section = SECTIONS.find((s) => s.id === sectionId);
+    if (!section)
+        return {
+            issues: [
+                { code: "settings.section", severity: "error", message: `unknown section ${sectionId}` },
+            ],
+        };
+    const doc = parseDocument(yamlText);
+    // A field whose value did not change is left untouched: defaults stay implicit, formatting stays.
+    const before = parseConfig(yamlText).config;
+    const canon = (v) => Array.isArray(v)
+        ? v.map(canon)
+        : v && typeof v === "object"
+            ? Object.fromEntries(Object.entries(v)
+                .filter(([, x]) => x !== undefined)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([k, x]) => [k, canon(x)]))
+            : v;
+    const same = (a, b) => JSON.stringify(canon(a)) === JSON.stringify(canon(b));
+    const unchanged = (path, value) => before !== undefined && same(value, currentValue(before, { path }));
+    if (section.rows === "team") {
+        const members = rowIndices(form, "member").flatMap((i) => {
+            const id = form.get(`member.${i}.id`)?.trim();
+            if (!id || form.get(`member.${i}.remove`))
+                return [];
+            const handle = form.get(`member.${i}.handle`)?.trim();
+            const areas = lines(form.get(`member.${i}.areas`) ?? "");
+            return [
+                {
+                    id,
+                    ...(handle ? { handle } : {}),
+                    role: form.get(`member.${i}.role`) ?? "member",
+                    areas,
+                    ...(form.get(`member.${i}.optOut`) ? { optOut: true } : {}),
+                },
+            ];
+        });
+        if (!unchanged(["team", "members"], members))
+            doc.setIn(["team", "members"], doc.createNode(members));
+    }
+    else if (section.rows === "teams") {
+        const teams = {};
+        for (const i of rowIndices(form, "teamrow")) {
+            const name = form.get(`teamrow.${i}.name`)?.trim();
+            if (!name || form.get(`teamrow.${i}.remove`))
+                continue;
+            const handle = form.get(`teamrow.${i}.handle`)?.trim();
+            teams[name] = {
+                ...(handle ? { handle } : {}),
+                members: lines(form.get(`teamrow.${i}.members`) ?? ""),
+                areas: lines(form.get(`teamrow.${i}.areas`) ?? ""),
+                repos: lines(form.get(`teamrow.${i}.repos`) ?? ""),
+            };
+        }
+        if (Object.keys(teams).length)
+            doc.setIn(["teams"], doc.createNode(teams));
+        else if (doc.has("teams"))
+            doc.delete("teams");
+    }
+    else if (section.rows === "areas") {
+        const areas = {};
+        for (const i of rowIndices(form, "area")) {
+            const name = form.get(`area.${i}.name`)?.trim();
+            if (!name || form.get(`area.${i}.remove`))
+                continue;
+            areas[name] = lines(form.get(`area.${i}.globs`) ?? "");
+        }
+        if (!unchanged(["areas"], areas))
+            doc.setIn(["areas"], doc.createNode(areas));
+    }
+    else {
+        for (const field of section.fields ?? []) {
+            const name = field.path.join(".");
+            const raw = form.get(name);
+            if (field.path.join(".") === "sources.host" && !raw) {
+                doc.deleteIn(["sources"]);
+                break;
+            }
+            // An empty number or optional text means "use the default", so the key is removed.
+            const clear = (field.kind === "number" && (raw === null || raw === "")) ||
+                (field.kind !== "checkbox" &&
+                    field.kind !== "checks" &&
+                    field.kind !== "lines" &&
+                    field.kind !== "number" &&
+                    field.optional &&
+                    !raw?.trim());
+            if (clear) {
+                if (doc.hasIn(field.path))
+                    doc.deleteIn(field.path);
+                continue;
+            }
+            const value = field.kind === "checkbox"
+                ? form.get(name) === "on"
+                : field.kind === "checks"
+                    ? form.getAll(name)
+                    : field.kind === "lines"
+                        ? lines(raw ?? "")
+                        : field.kind === "number"
+                            ? Number(raw)
+                            : raw?.trim();
+            if (value === undefined || unchanged(field.path, value))
+                continue;
+            doc.setIn(field.path, Array.isArray(value) ? doc.createNode(value) : value);
+        }
+    }
+    // Drop sections that became empty maps, so the defaults apply.
+    for (const key of ["notifications", "distribution", "scoring", "security"]) {
+        const node = doc.get(key, true);
+        if (isMap(node) && node.items.length === 0)
+            doc.delete(key);
+    }
+    const text = doc.toString({ flowCollectionPadding: false });
+    const { config, issues } = parseConfig(text);
+    return config ? { text, issues: [] } : { issues };
+}
+/** Row numbers present in the form for a row editor (`member.0.id`, `member.3.id`, ...). */
+function rowIndices(form, prefix) {
+    const seen = new Set();
+    for (const key of form.keys()) {
+        const m = new RegExp(`^${prefix}\\.(\\d+)\\.`).exec(key);
+        if (m)
+            seen.add(Number(m[1]));
+    }
+    return [...seen].sort((a, b) => a - b);
+}

package/dist/src/views.d.ts

@@ -0,0 +1,36 @@
+import { type Config, type Entry, type Event, type Issue, type SectionUsage } from "@homeostat/core";
+import type { AgentLiveness, Contribution, DesirePath, Health, Impact } from "./metrics.ts";
+import { type Section } from "./settings.ts";
+export declare function layout(opts: {
+    title: string;
+    path: string;
+    kbRoot: string;
+    body: string;
+    theme?: "light" | "dark";
+}): string;
+export declare function overviewPage(h: Health, agents: AgentLiveness[], imp: Impact, recent: Event[]): string;
+export declare function entriesPage(entries: readonly Entry[], status: string | null): string;
+export declare function entryPage(entry: Entry, config: Config): string;
+export declare function membersPage(rowsData: Contribution[]): string;
+export declare function coveragePage(cov: {
+    areas: {
+        area: string;
+        globs: readonly string[];
+        accepted: number;
+        candidates: number;
+    }[];
+    sources: {
+        repo: string;
+        entries: number;
+    }[];
+}): string;
+export declare function impactPage(imp: Impact): string;
+export declare function documentsPage(usage: readonly SectionUsage[]): string;
+export declare function desirePathsPage(paths: DesirePath[]): string;
+export declare function eventsPage(events: Event[]): string;
+export declare function settingsIndex(): string;
+export declare function settingsPage(section: Section, config: Config, token: string, notice?: {
+    saved?: boolean;
+    issues?: Issue[];
+}): string;
+export declare function messagePage(title: string, text: string): string;