waypoint-codex 0.1.6 → 0.1.8

package/README.md

@@ -50,6 +50,7 @@ repo/
 - `waypoint init` — scaffold or refresh the repo
 - `waypoint doctor` — check for drift and missing pieces
 - `waypoint sync` — rebuild `.waypoint/DOCS_INDEX.md` and sync optional automations/rules
+- `waypoint upgrade` — update the global Waypoint CLI and refresh the current repo with its existing config
 - `waypoint import-legacy` — import from an older repo layout
 
 ## Shipped skills
@@ -71,9 +72,13 @@ If you initialize with `--with-roles`, Waypoint scaffolds:
 ## Update
 
 ```bash
-npm install -g waypoint-codex@latest
-waypoint init --with-automations --with-roles
-waypoint doctor
+waypoint upgrade
+```
+
+If you only want to update the CLI without refreshing the repo:
+
+```bash
+waypoint upgrade --skip-repo-refresh
 ```
 
 ## Learn more

package/dist/src/cli.js

@@ -4,7 +4,8 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import process from "node:process";
-import { doctorRepository, importLegacyRepo, initRepository, syncRepository } from "./core.js";
+import { doctorRepository, importLegacyRepo, initRepository, loadWaypointConfig, syncRepository } from "./core.js";
+import { upgradeWaypoint } from "./upgrade.js";
 const VERSION = JSON.parse(readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8")).version;
 function resolveRepo(input) {
     return path.resolve(input ?? ".");
@@ -29,6 +30,7 @@ Commands:
   init                Initialize a repository with Waypoint scaffolding
   doctor              Validate repository health and report drift
   sync                Rebuild docs index and sync optional user-home artifacts
+  upgrade             Update the global Waypoint CLI and refresh this repo using existing config
   import-legacy       Analyze a legacy repository layout and produce a Waypoint adoption report
 `);
 }
@@ -128,6 +130,23 @@ async function main() {
         }
         return 0;
     }
+    if (command === "upgrade") {
+        const { values, positionals } = parseArgs({
+            args: argv.slice(1),
+            options: {
+                "skip-repo-refresh": { type: "boolean", default: false }
+            },
+            allowPositionals: true
+        });
+        const projectRoot = resolveRepo(positionals[0]);
+        const config = loadWaypointConfig(projectRoot);
+        return upgradeWaypoint({
+            projectRoot,
+            config,
+            cliEntry: process.argv[1] ? path.resolve(process.argv[1]) : fileURLToPath(import.meta.url),
+            skipRepoRefresh: values["skip-repo-refresh"],
+        });
+    }
     console.error(`Unknown command: ${command}`);
     printHelp();
     return 2;

package/dist/src/upgrade.js

@@ -0,0 +1,55 @@
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+export function npmBinaryForPlatform(platform = process.platform) {
+    return platform === "win32" ? "npm.cmd" : "npm";
+}
+export function buildInitArgs(projectRoot, config) {
+    const args = ["init", projectRoot];
+    if (config.profile === "app-friendly") {
+        args.push("--app-friendly");
+    }
+    const featureMap = config.features ?? {};
+    if (featureMap.roles) {
+        args.push("--with-roles");
+    }
+    if (featureMap.rules) {
+        args.push("--with-rules");
+    }
+    if (featureMap.automations) {
+        args.push("--with-automations");
+    }
+    return args;
+}
+function hasWaypointConfig(projectRoot) {
+    return existsSync(path.join(projectRoot, ".waypoint/config.toml"));
+}
+export function upgradeWaypoint(options) {
+    const nodeBinary = options.nodeBinary ?? process.execPath;
+    const npmBinary = options.npmBinary ?? process.env.WAYPOINT_NPM_COMMAND ?? npmBinaryForPlatform();
+    const stdio = options.stdio ?? "inherit";
+    const update = spawnSync(npmBinary, ["install", "-g", "waypoint-codex@latest"], {
+        stdio,
+    });
+    if ((update.status ?? 1) !== 0) {
+        return update.status ?? 1;
+    }
+    if (options.skipRepoRefresh) {
+        console.log("Waypoint CLI updated. Skipped repo refresh.");
+        return 0;
+    }
+    if (!hasWaypointConfig(options.projectRoot)) {
+        console.log("Waypoint CLI updated. No repo-local Waypoint config found, so repo refresh was skipped.");
+        return 0;
+    }
+    const init = spawnSync(nodeBinary, [options.cliEntry, ...buildInitArgs(options.projectRoot, options.config)], {
+        stdio,
+    });
+    if ((init.status ?? 1) !== 0) {
+        return init.status ?? 1;
+    }
+    const doctor = spawnSync(nodeBinary, [options.cliEntry, "doctor", options.projectRoot], {
+        stdio,
+    });
+    return doctor.status ?? 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waypoint-codex",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Codex-native repository operating system: scaffolding, docs routing, repo-local skills, doctor, and sync.",
   "license": "MIT",
   "type": "module",

package/templates/.waypoint/scripts/prepare-context.mjs

@@ -23,18 +23,98 @@ function ensureDir(dirPath) {
   mkdirSync(dirPath, { recursive: true });
 }
 
-function safeExec(command, cwd) {
+function runCommand(command, cwd) {
   try {
-    return execFileSync(command[0], command.slice(1), {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"],
-      encoding: "utf8",
-    }).trim();
-  } catch {
-    return "";
+    return {
+      ok: true,
+      stdout: execFileSync(command[0], command.slice(1), {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf8",
+      }).trim(),
+      stderr: "",
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      stdout: typeof error?.stdout === "string" ? error.stdout.trim() : "",
+      stderr:
+        typeof error?.stderr === "string" && error.stderr.trim().length > 0
+          ? error.stderr.trim()
+          : error instanceof Error
+            ? error.message
+            : "Unknown command failure",
+    };
   }
 }
 
+function safeExec(command, cwd) {
+  const result = runCommand(command, cwd);
+  return result.ok ? result.stdout : "";
+}
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function currentAuthorFilter(projectRoot) {
+  const email = runCommand(["git", "config", "user.email"], projectRoot);
+  if (email.ok && email.stdout) {
+    return {
+      label: email.stdout,
+      pattern: escapeRegex(email.stdout),
+    };
+  }
+
+  const name = runCommand(["git", "config", "user.name"], projectRoot);
+  if (name.ok && name.stdout) {
+    return {
+      label: name.stdout,
+      pattern: `^${escapeRegex(name.stdout)}\\s<`,
+    };
+  }
+
+  return null;
+}
+
+function githubPullRequestContext(projectRoot) {
+  const repo = runCommand(["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"], projectRoot);
+  if (!repo.ok || !repo.stdout) {
+    return {
+      ok: false,
+      error: repo.stderr || "Could not resolve GitHub repository from this checkout.",
+    };
+  }
+
+  const viewer = runCommand(["gh", "api", "user", "--jq", ".login"], projectRoot);
+  if (!viewer.ok || !viewer.stdout) {
+    return {
+      ok: false,
+      error: viewer.stderr || "Could not resolve active GitHub user.",
+    };
+  }
+
+  return {
+    ok: true,
+    repo: repo.stdout,
+    viewer: viewer.stdout,
+  };
+}
+
+function renderCommandBlock(result, emptyMessage) {
+  if (!result.ok) {
+    return `Command failed: ${result.stderr}`;
+  }
+  return result.stdout || emptyMessage;
+}
+
+function renderPullRequestBlock(result, emptyMessage) {
+  if (!result.ok) {
+    return `Command failed: ${result.error || result.stderr}`;
+  }
+  return result.stdout || emptyMessage;
+}
+
 const SESSION_DIR_NAMES = ["sessions", "archived_sessions"];
 const SECRET_PATTERNS = [
   /npm_[A-Za-z0-9]+/g,
@@ -242,6 +322,25 @@ function writeRecentThread(contextDir, projectRoot) {
     return filePath;
   }
 
+  if (!snapshot.selectedFromPreCompaction) {
+    writeFileSync(
+      filePath,
+      [
+        "# Recent Thread",
+        "",
+        `Generated by \`${path.relative(projectRoot, fileURLToPath(import.meta.url))}\` on ${generatedAt}.`,
+        "",
+        `- Source session: \`${path.relative(codexHome(), snapshot.path)}\``,
+        `- Session cwd: \`${snapshot.sessionCwd}\``,
+        `- Compactions in source session: ${snapshot.compactionCount}`,
+        "- No compaction was found in the latest matching local Codex session, so there is nothing to restore into startup context yet.",
+        "",
+      ].join("\n"),
+      "utf8"
+    );
+    return filePath;
+  }
+
   const selectedTurns = snapshot.turns.slice(-MAX_RECENT_TURNS);
   const relSessionPath = path.relative(codexHome(), snapshot.path);
   const lines = [
@@ -329,34 +428,49 @@ function main() {
     contextDir,
     "UNCOMMITTED_CHANGES.md",
     "Uncommitted Changes",
-    [
-      "## Status",
-      "",
-      "```",
-      safeExec(["git", "status", "--short", "--branch"], projectRoot) || "No uncommitted changes.",
-      "```",
-      "",
-      "## Diff Stat",
-      "",
-      "```",
-      safeExec(["git", "diff", "--stat"], projectRoot) || "No unstaged tracked diff.",
-      "```",
-      "",
-      "## Staged Diff Stat",
-      "",
-      "```",
-      safeExec(["git", "diff", "--stat", "--cached"], projectRoot) || "No staged diff.",
-      "```",
-    ].join("\n")
+    (() => {
+      const status = runCommand(["git", "status", "--short", "--branch"], projectRoot);
+      const unstaged = runCommand(["git", "diff", "--stat"], projectRoot);
+      const staged = runCommand(["git", "diff", "--stat", "--cached"], projectRoot);
+      return [
+        "## Status",
+        "",
+        "```",
+        renderCommandBlock(status, "No uncommitted changes."),
+        "```",
+        "",
+        "## Diff Stat",
+        "",
+        "```",
+        renderCommandBlock(unstaged, "No unstaged tracked diff."),
+        "```",
+        "",
+        "## Staged Diff Stat",
+        "",
+        "```",
+        renderCommandBlock(staged, "No staged diff."),
+        "```",
+      ].join("\n");
+    })()
   );
 
+  const authorFilter = currentAuthorFilter(projectRoot);
+  const recentCommitsResult = authorFilter
+    ? runCommand(["git", "log", `--author=${authorFilter.pattern}`, "--format=%h%d %s (%cr)", "-20", "--all"], projectRoot)
+    : {
+        ok: false,
+        stdout: "",
+        stderr: "Could not determine current git author from local git config.",
+      };
   const recentCommitsPath = writeContextFile(
     contextDir,
     "RECENT_COMMITS.md",
     "Recent Commits",
     [
+      authorFilter ? `Author filter: ${authorFilter.label}` : "Author filter: unavailable",
+      "",
       "```",
-      safeExec(["git", "log", "--format=%h%d %s (%cr)", "-20", "--all"], projectRoot) || "No recent commits found.",
+      renderCommandBlock(recentCommitsResult, "No recent commits found for the current author."),
       "```",
     ].join("\n")
   );
@@ -375,57 +489,71 @@ function main() {
     nestedRepoSections.join("\n\n") || "No nested repositories found."
   );
 
-  const openPrs = safeExec(
-    [
-      "gh",
-      "pr",
-      "list",
-      "--state",
-      "open",
-      "--author",
-      "@me",
-      "--limit",
-      "5",
-      "--json",
-      "number,title,author,headRefName",
-      "--template",
-      "{{range .}}#{{.number}} {{.title}} ({{.author.login}}) [{{.headRefName}}]\n{{end}}",
-    ],
-    projectRoot
-  );
-  const mergedPrs = safeExec(
-    [
-      "gh",
-      "pr",
-      "list",
-      "--state",
-      "merged",
-      "--author",
-      "@me",
-      "--limit",
-      "5",
-      "--json",
-      "number,title,author,mergedAt",
-      "--template",
-      "{{range .}}#{{.number}} {{.title}} ({{.author.login}}) merged {{timeago .mergedAt}}\n{{end}}",
-    ],
-    projectRoot
-  );
+  const prContext = githubPullRequestContext(projectRoot);
+  const openPrs =
+    prContext.ok
+      ? runCommand(
+          [
+            "gh",
+            "pr",
+            "list",
+            "--repo",
+            prContext.repo,
+            "--state",
+            "open",
+            "--author",
+            prContext.viewer,
+            "--limit",
+            "5",
+            "--json",
+            "number,title,author,headRefName",
+            "--template",
+            "{{range .}}#{{.number}} {{.title}} ({{.author.login}}) [{{.headRefName}}]\n{{end}}",
+          ],
+          projectRoot
+        )
+      : prContext;
+  const mergedPrs =
+    prContext.ok
+      ? runCommand(
+          [
+            "gh",
+            "pr",
+            "list",
+            "--repo",
+            prContext.repo,
+            "--state",
+            "merged",
+            "--author",
+            prContext.viewer,
+            "--limit",
+            "5",
+            "--json",
+            "number,title,author,mergedAt",
+            "--template",
+            "{{range .}}#{{.number}} {{.title}} ({{.author.login}}) merged {{timeago .mergedAt}}\n{{end}}",
+          ],
+          projectRoot
+        )
+      : prContext;
   const prsPath = writeContextFile(
     contextDir,
     "PULL_REQUESTS.md",
     "Pull Requests",
     [
+      prContext.ok ? `GitHub viewer: ${prContext.viewer}` : `GitHub context: ${prContext.error}`,
+      prContext.ok ? `GitHub repo: ${prContext.repo}` : "",
+      "",
       "## Open PRs",
       "",
       "```",
-      openPrs || "No open PRs found.",
+      renderPullRequestBlock(openPrs, "No open PRs found for the current GitHub user."),
       "```",
       "",
       "## Recently Merged PRs",
       "",
       "```",
-      mergedPrs || "No recently merged PRs found.",
+      renderPullRequestBlock(mergedPrs, "No recently merged PRs found for the current GitHub user."),
       "```",
     ].join("\n")
   );