@saadnvd1/agent-os 0.3.781 → 0.3.786

package/scripts/autodeploy.test.ts

@@ -113,6 +113,59 @@ describe("autodeploy restart gap", () => {
   });
 });
 
+describe("autodeploy changelog commits", () => {
+  const changelog = (t: ReturnType<typeof setup>, also?: string) => {
+    const work = path.join(t.root, "work");
+    fs.mkdirSync(path.join(work, "content"), { recursive: true });
+    fs.writeFileSync(path.join(work, "content/whats-new.json"), "{}\n");
+    if (also) fs.appendFileSync(path.join(work, "f"), also + "\n");
+    sh(work, "add", "-A");
+    sh(
+      work,
+      "-c",
+      "user.name=t",
+      "-c",
+      "user.email=t@t",
+      "commit",
+      "-qm",
+      "chore(whats-new): add 1 entries"
+    );
+    sh(work, "push", "-q", "origin", "main");
+    return sh(work, "rev-parse", "HEAD");
+  };
+
+  it("pulls a commit that touches only the changelog without a restart", () => {
+    const t = setup();
+    const a = t.commit("a");
+    t.run();
+    expect(t.restarts()).toBe(1);
+
+    const b = changelog(t);
+    expect(t.run()).toBe("");
+    expect(t.deployed()).toBe(b);
+    expect(t.deployed()).not.toBe(a);
+    expect(t.restarts()).toBe(1);
+    expect(fs.existsSync(path.join(t.clone, "content/whats-new.json"))).toBe(
+      true
+    );
+    expect(t.run()).toBe("");
+  });
+
+  it("still redeploys a commit that touches the changelog and something else", () => {
+    const t = setup();
+    t.commit("a");
+    t.run();
+    const c = changelog(t, "more");
+    fs.writeFileSync(
+      path.join(t.state, "restarted"),
+      `${Math.floor(Date.now() / 1000) - 3601}\n`
+    );
+    expect(t.run()).toContain("Deploying");
+    expect(t.deployed()).toBe(c);
+    expect(t.restarts()).toBe(2);
+  });
+});
+
 describe("autodeploy CLI links", () => {
   it("repoints a link into another clone at the live checkout after a deploy", () => {
     const t = setup();

package/scripts/whats-new.ts

@@ -0,0 +1,118 @@
+// Adds the changelog entries for merges since the last run to
+// content/whats-new.json. Run by scripts/autodeploy on the machine that
+// publishes; installs only ever read the file.
+//   whats-new.ts [--since-days N] [--through-file F] [--commit] [--dry-run]
+// --commit also commits just that file and pushes it to origin/main.
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { askHaiku } from "@/lib/whats-new/claude";
+import { generate, type PrInfo } from "@/lib/whats-new/generate";
+import { WHATS_NEW_FILE } from "@/lib/whats-new/load";
+import { readBlocklist } from "@/lib/whats-new/lint";
+
+const root = process.cwd();
+const args = process.argv.slice(2);
+const flag = (name: string) => args.includes(name);
+const value = (name: string) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+
+const run = (cmd: string, a: string[]) =>
+  execFileSync(cmd, a, { cwd: root, encoding: "utf-8", maxBuffer: 64 << 20 });
+const git = (a: string[]) => run("git", a);
+
+function prs(numbers: number[]): Map<number, PrInfo> {
+  const rows = JSON.parse(
+    run("gh", [
+      "pr",
+      "list",
+      "--state",
+      "merged",
+      "--limit",
+      "1000",
+      "--json",
+      "number,body,url",
+    ])
+  ) as { number: number; body: string; url: string }[];
+  const want = new Set(numbers);
+  return new Map(
+    rows.filter((r) => want.has(r.number)).map((r) => [r.number, r])
+  );
+}
+
+async function main() {
+  const throughFile = value("--through-file");
+  const commit = flag("--commit");
+  if (commit) {
+    git(["fetch", "-q", "origin", "main"]);
+    const onMain = git(["rev-parse", "--abbrev-ref", "HEAD"]).trim() === "main";
+    const level =
+      git(["rev-parse", "HEAD"]).trim() ===
+      git(["rev-parse", "origin/main"]).trim();
+    if (
+      !onMain ||
+      !level ||
+      git(["status", "--porcelain", "--untracked-files=no"]).trim()
+    ) {
+      console.log("whats-new: checkout is not a clean, current main; skipped");
+      return;
+    }
+  }
+  let through =
+    throughFile && fs.existsSync(throughFile)
+      ? fs.readFileSync(throughFile, "utf-8").trim()
+      : null;
+  if (through) {
+    try {
+      git(["cat-file", "-e", `${through}^{commit}`]);
+    } catch {
+      through = null;
+    }
+  }
+  const before = git(["rev-parse", "HEAD"]).trim();
+  const result = await generate(
+    root,
+    {
+      through,
+      sinceDays: Number(value("--since-days") ?? 30),
+      write: !flag("--dry-run"),
+    },
+    { git, prs, ask: askHaiku, blocklist: readBlocklist() }
+  );
+  console.log(
+    `whats-new: ${result.added.length} added, ${result.skipped} skipped, ${result.dropped.length} dropped`
+  );
+  for (const d of result.dropped)
+    console.log(`  dropped #${d.pr}: ${d.reason}`);
+  if (flag("--dry-run")) return;
+
+  if (commit && result.added.length) {
+    git(["add", WHATS_NEW_FILE]);
+    git([
+      "commit",
+      "-q",
+      "--no-verify",
+      "-m",
+      `chore(whats-new): add ${result.added.length} entries`,
+      "--",
+      WHATS_NEW_FILE,
+    ]);
+    try {
+      git(["push", "-q", "origin", "HEAD:main"]);
+    } catch (e) {
+      git(["reset", "-q", "--hard", before]);
+      throw e;
+    }
+  }
+  if (throughFile) {
+    fs.mkdirSync(path.dirname(throughFile), { recursive: true });
+    fs.writeFileSync(throughFile, `${before}\n`);
+  }
+}
+
+main().catch((e) => {
+  console.error(`whats-new: ${e instanceof Error ? e.message : e}`);
+  process.exit(1);
+});

package/stores/whatsNew.ts

@@ -0,0 +1,16 @@
+import { proxy } from "valtio";
+
+// Whether the What's New dialog is open, so the footer row and the update
+// banner can both open the one dialog. `preview` opens it showing what a
+// waiting update would add.
+export const whatsNewStore = proxy({ open: false, preview: false });
+
+export const whatsNewActions = {
+  open: (preview = false) => {
+    whatsNewStore.preview = preview;
+    whatsNewStore.open = true;
+  },
+  close: () => {
+    whatsNewStore.open = false;
+  },
+};

package/components/Draft/draftModels.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { draftModels } from "./draftModels";
-
-const qwen = { value: "ollama/qwen3", label: "Qwen 3" };
-
-describe("draftModels", () => {
-  it("lists the default and then what OpenCode reports", () => {
-    const list = draftModels("opencode", {
-      data: [qwen],
-      isPending: false,
-      isError: false,
-    });
-    expect(list.map((m) => m.value)).toEqual(["default", "ollama/qwen3"]);
-  });
-
-  it("says so beside the default while loading and on failure", () => {
-    const loading = draftModels("opencode", {
-      isPending: true,
-      isError: false,
-    });
-    const failed = draftModels("opencode", { isPending: false, isError: true });
-    expect(loading).toHaveLength(1);
-    expect(loading[0].label).toContain("loading");
-    expect(failed[0].label).toContain("couldn't");
-  });
-
-  it("keeps a fixed list as it is", () => {
-    const list = draftModels("claude", { isPending: true, isError: false });
-    expect(list.map((m) => m.value)).toContain("opus");
-  });
-});

package/components/Draft/draftModels.ts

@@ -1,17 +0,0 @@
-import type { ChatModel } from "@/lib/chat/events";
-import type { Draft } from "@/lib/drafts";
-import { discoversModels, getModelOptions } from "@/lib/model-catalog";
-
-// A fixed list, or the agent's default followed by what it reports; while it
-// loads or if it fails, the default alone says so.
-export function draftModels(
-  agentType: Draft["agentType"],
-  found: { data?: ChatModel[]; isPending: boolean; isError: boolean }
-): ChatModel[] {
-  const options = getModelOptions(agentType);
-  if (!discoversModels(agentType)) return options;
-  if (found.data) return [...options, ...found.data];
-  const [first, ...rest] = options;
-  const note = found.isError ? "couldn't list models" : "loading models…";
-  return [{ ...first, label: `${first.label} (${note})` }, ...rest];
-}