niahere 0.2.19 → 0.2.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/skills/gh-stamp/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: gh-stamp
+description: "Stamp a GitHub PR with an LGTM approval comment. Use when someone wants to approve, stamp, or give a thumbs-up to a pull request."
+---
+
+# gh-stamp
+
+Approve-stamp a GitHub PR by posting a comment.
+
+## Trigger
+
+User says "stamp", "stamp it", "stmap", or similar.
+
+- Stamp only → use this skill alone.
+- Stamp + review → run this skill first, then the pr-reviewer skill.
+- Review only → use the pr-reviewer skill, not this.
+
+## Steps
+
+1. **Find the PR.** Accept a full URL, `owner/repo#number`, or a bare number if the repo is obvious from context. If unclear, ask and stop.
+2. **Post the comment.**
+   ```sh
+   gh pr comment <pr-url-or-number> --body "LGTM, Stamped ✅"
+   # or with repo qualifier:
+   gh pr comment --repo <owner/repo> <number> --body "LGTM, Stamped ✅"
+   ```
+3. **Confirm to user:** `LGTM, Stamped ✅`
+
+Do not touch anything else on the PR.

package/src/core/runner.ts

@@ -1,24 +1,119 @@
 import { homedir } from "os";
 import { existsSync } from "fs";
+import { randomUUID } from "crypto";
+import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { JobInput, JobResult } from "../types";
 import { appendAudit, readState, writeState } from "../utils/logger";
 import type { AuditEntry, JobState } from "../types";
 import { getConfig } from "../utils/config";
 import { buildSystemPrompt } from "../chat/identity";
 
-// Resolve full path to codex so daemon doesn't depend on PATH
-const CODEX_CANDIDATES = ["/opt/homebrew/bin/codex", "/usr/local/bin/codex"];
-const codexPath = CODEX_CANDIDATES.find((p) => existsSync(p)) || "codex";
+interface RunnerOutput {
+  agentText: string;
+  sessionId: string;
+  error?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Codex runner
+// ---------------------------------------------------------------------------
+
+function resolveCodexPath(): string {
+  const candidates = ["/opt/homebrew/bin/codex", "/usr/local/bin/codex"];
+  return candidates.find((p) => existsSync(p)) || "codex";
+}
+
+async function runJobWithCodex(fullPrompt: string, cwd: string, model: string): Promise<RunnerOutput> {
+  const codexPath = resolveCodexPath();
+  const args = [codexPath, "exec", fullPrompt, "-C", cwd, "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox"];
+  if (model && model !== "default") {
+    args.splice(3, 0, "-m", model);
+  }
 
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env },
+  });
+
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+
+  let agentText = "";
+  let sessionId = "";
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event.type === "thread.started" && event.thread_id) {
+        sessionId = event.thread_id;
+      }
+      if (event.type === "item.completed" && event.item?.type === "agent_message") {
+        agentText = event.item.text || "";
+      }
+    } catch {}
+  }
 
-function buildPrompt(job: JobInput): string {
-  const systemPrompt = buildSystemPrompt("job");
-  return `${systemPrompt}\n\n---\n\nJob: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
+  if (exitCode !== 0) {
+    return { agentText, sessionId, error: stderr.trim() || `exit code ${exitCode}` };
+  }
+  return { agentText, sessionId };
 }
 
+// ---------------------------------------------------------------------------
+// Claude Agent SDK runner
+// ---------------------------------------------------------------------------
+
+async function runJobWithClaude(systemPrompt: string, jobPrompt: string, cwd: string): Promise<RunnerOutput> {
+  const sessionId = randomUUID();
+
+  // One-shot async iterable: emit a single user message then close
+  async function* singleMessage() {
+    yield {
+      type: "user" as const,
+      message: { role: "user" as const, content: jobPrompt },
+      parent_tool_use_id: null,
+      session_id: "",
+    };
+  }
+
+  const handle = query({
+    prompt: singleMessage() as any,
+    options: {
+      systemPrompt,
+      cwd,
+      permissionMode: "bypassPermissions",
+      sessionId,
+    } as any,
+  });
+
+  let agentText = "";
+  let actualSessionId = sessionId;
+
+  for await (const message of handle) {
+    if (message.type === "system" && (message as any).subtype === "init") {
+      actualSessionId = (message as any).session_id || sessionId;
+    }
+    if (message.type === "result") {
+      if (!(message as any).is_error) {
+        agentText = (message as any).result || "";
+      } else {
+        const errors = (message as any).errors;
+        return { agentText: "", sessionId: actualSessionId, error: errors?.join(", ") || "unknown error" };
+      }
+    }
+  }
+
+  return { agentText, sessionId: actualSessionId };
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
 export async function runJob(job: JobInput): Promise<JobResult> {
   const config = getConfig();
-  const model = config.model;
   const timestamp = new Date().toISOString();
   const startMs = performance.now();
 
@@ -28,48 +123,29 @@ export async function runJob(job: JobInput): Promise<JobResult> {
   writeState(state);
 
   try {
-    const fullPrompt = buildPrompt(job);
     const cwd = homedir();
-    const args = [codexPath, "exec", fullPrompt, "-C", cwd, "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox"];
-    if (model && model !== "default") {
-      args.splice(3, 0, "-m", model);
+    let output: RunnerOutput;
+
+    if (config.runner === "codex") {
+      const fullPrompt = `${buildSystemPrompt("job")}\n\n---\n\nJob: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
+      output = await runJobWithCodex(fullPrompt, cwd, config.model);
+    } else {
+      const systemPrompt = buildSystemPrompt("job");
+      const jobPrompt = `Job: ${job.name} (schedule: ${job.schedule})\n\n${job.prompt}`;
+      output = await runJobWithClaude(systemPrompt, jobPrompt, cwd);
     }
-    const proc = Bun.spawn(args, {
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env },
-    });
 
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
     const duration_ms = Math.round(performance.now() - startMs);
+    const ok = !output.error;
 
-    // Parse JSONL events for session ID and final agent message
-    let agentText = "";
-    let sessionId = "";
-    for (const line of stdout.split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        const event = JSON.parse(line);
-        if (event.type === "thread.started" && event.thread_id) {
-          sessionId = event.thread_id;
-        }
-        if (event.type === "item.completed" && event.item?.type === "agent_message") {
-          agentText = event.item.text || "";
-        }
-      } catch {}
-    }
-
-    const ok = exitCode === 0;
     const result: JobResult = {
       job: job.name,
       timestamp,
       status: ok ? "ok" : "error",
-      result: agentText.trim(),
+      result: output.agentText.trim(),
       duration_ms,
-      session_id: sessionId || undefined,
-      error: ok ? undefined : stderr.trim() || `exit code ${exitCode}`,
+      session_id: output.sessionId || undefined,
+      error: output.error,
     };
 
     const auditEntry: AuditEntry = {

package/src/types/config.ts

@@ -25,6 +25,7 @@ export interface ChannelsConfig {
 
 export interface Config {
   model: string;
+  runner: "claude" | "codex";
   timezone: string;
   activeHours: { start: string; end: string };
   database_url: string;

package/src/utils/config.ts

@@ -10,6 +10,7 @@ const TIME_RE = /^\d{2}:\d{2}$/;
 
 const DEFAULTS: Config = {
   model: "default",
+  runner: "claude",
   timezone: process.env.TZ || Intl.DateTimeFormat().resolvedOptions().timeZone,
   activeHours: { start: "00:00", end: "23:59" },
   database_url: DEFAULT_DATABASE_URL,
@@ -54,6 +55,9 @@ export function loadConfig(): Config {
   // Model
   const model = typeof raw.model === "string" ? raw.model : DEFAULTS.model;
 
+  // Runner — "codex" is opt-in, everything else defaults to "claude"
+  const runner: Config["runner"] = raw.runner === "codex" ? "codex" : DEFAULTS.runner;
+
   // Timezone
   let timezone = DEFAULTS.timezone;
   if (typeof raw.timezone === "string") {
@@ -140,6 +144,7 @@ export function loadConfig(): Config {
 
   return {
     model,
+    runner,
     timezone,
     activeHours: { start, end },
     database_url,