niahere 0.2.13 → 0.2.15

package/src/cli/index.ts

@@ -136,10 +136,58 @@ switch (command) {
     if (prompt) {
       const { createChatEngine } = await import("../chat/engine");
       const { getMcpServers } = await import("../mcp");
+      const DIM = "\x1b[2m";
+      const RST = "\x1b[0m";
+      const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+      let frame = 0;
+      let statusText = "thinking";
+      let spinTimer: ReturnType<typeof setInterval> | null = null;
+      let streamedLen = 0;
+      let streaming = false;
+
+      const renderSpinner = () => {
+        process.stderr.write(`\x1b[2K\r${DIM}  ${FRAMES[frame]} ${statusText}${RST}`);
+        frame = (frame + 1) % FRAMES.length;
+      };
+
       await withDb(async () => {
         const engine = await createChatEngine({ room: "cli-run", channel: "terminal", resume: false, mcpServers: getMcpServers() });
-        const { result } = await engine.send(prompt);
-        console.log(result.trim());
+        spinTimer = setInterval(renderSpinner, 80);
+        renderSpinner();
+
+        const { result, costUsd, turns } = await engine.send(prompt, {
+          onStream(textSoFar) {
+            if (!streaming) {
+              if (spinTimer) { clearInterval(spinTimer); spinTimer = null; }
+              process.stderr.write("\x1b[2K\r");
+              streaming = true;
+            }
+            const chunk = textSoFar.slice(streamedLen);
+            if (chunk) { process.stdout.write(chunk); streamedLen = textSoFar.length; }
+          },
+          onActivity(text) {
+            if (!streaming) statusText = text;
+          },
+        });
+
+        if (spinTimer) { clearInterval(spinTimer); spinTimer = null; }
+
+        if (!streaming && result.trim()) {
+          process.stderr.write("\x1b[2K\r");
+          process.stdout.write(result.trim());
+        } else if (streaming) {
+          const rest = result.slice(streamedLen);
+          if (rest.trim()) process.stdout.write(rest);
+        } else {
+          process.stderr.write("\x1b[2K\r");
+        }
+
+        const costStr = costUsd > 0 ? `$${costUsd.toFixed(4)}` : "";
+        const turnsStr = turns > 0 ? `${turns} turn${turns !== 1 ? "s" : ""}` : "";
+        const meta = [costStr, turnsStr].filter(Boolean).join(" · ");
+        if (meta) process.stderr.write(`\n${DIM}${meta}${RST}`);
+        process.stdout.write("\n");
+
         engine.close();
       });
     } else {
@@ -192,8 +240,13 @@ switch (command) {
   }
 
   case "chat": {
-    const resume = process.argv[3] === "--resume" || process.argv[3] === "-r";
-    await startRepl(resume);
+    const arg = process.argv[3];
+    const mode = (arg === "--new" || arg === "-n")
+      ? "new" as const
+      : (arg === "--resume" || arg === "-r")
+        ? "pick" as const
+        : "continue" as const;
+    await startRepl(mode);
     break;
   }
 
@@ -223,6 +276,59 @@ switch (command) {
     break;
   }
 
+  case "config": {
+    const configSub = process.argv[3];
+    const configKey = process.argv[4];
+    const configVal = process.argv.slice(5).join(" ");
+    const { readRawConfig, updateRawConfig } = await import("../utils/config");
+
+    if (configSub === "set" && configKey) {
+      if (!configVal) fail("Usage: nia config set <key> <value>");
+      // Support dot notation for nested keys (e.g. channels.default)
+      const parts = configKey.split(".");
+      let obj: Record<string, unknown> = {};
+      let cursor = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        cursor[parts[i]] = {};
+        cursor = cursor[parts[i]] as Record<string, unknown>;
+      }
+      // Auto-detect booleans and numbers
+      let parsed: unknown = configVal;
+      if (configVal === "true") parsed = true;
+      else if (configVal === "false") parsed = false;
+      else if (/^\d+$/.test(configVal)) parsed = Number(configVal);
+      cursor[parts[parts.length - 1]] = parsed;
+      updateRawConfig(obj);
+      console.log(`${configKey} = ${configVal}`);
+    } else if (configSub === "get" && configKey) {
+      const raw = readRawConfig();
+      const parts = configKey.split(".");
+      let val: unknown = raw;
+      for (const p of parts) {
+        if (val && typeof val === "object") val = (val as Record<string, unknown>)[p];
+        else { val = undefined; break; }
+      }
+      if (val === undefined) {
+        console.log(`${configKey}: (not set)`);
+      } else if (typeof val === "object") {
+        const yaml = (await import("js-yaml")).default;
+        console.log(yaml.dump(val, { lineWidth: -1 }).trim());
+      } else {
+        console.log(`${configKey} = ${val}`);
+      }
+    } else if (!configSub || configSub === "list") {
+      const raw = readRawConfig();
+      const yaml = (await import("js-yaml")).default;
+      console.log(yaml.dump(raw, { lineWidth: -1 }).trim());
+    } else {
+      console.log("Usage: nia config <set|get|list>");
+      console.log("  nia config set <key> <value>  — set a config value");
+      console.log("  nia config get <key>          — get a config value");
+      console.log("  nia config list               — show all config");
+    }
+    break;
+  }
+
   case "channels": {
     const sub = process.argv[3];
     const { updateRawConfig } = await import("../utils/config");
@@ -286,13 +392,14 @@ switch (command) {
     console.log("  start / stop        — daemon + service control");
     console.log("  restart             — restart daemon");
     console.log("  status [--json --rooms N --all]  — show daemon, jobs, channels");
-    console.log("  chat [-r|--resume]  — interactive chat");
+    console.log("  chat                — interactive chat (auto-continues last session)");
     console.log("  run <prompt>        — one-shot execution");
     console.log("  history [room]      — recent messages");
     console.log("  logs [-f]           — daemon logs");
     console.log("  job <sub>           — manage jobs");
     console.log("  db <sub>            — database setup/status/migrate");
     console.log("  skills              — list available skills");
+    console.log("  config <sub>        — get/set/list config values");
     console.log("  send [-c ch] <msg>  — send a message via channel");
     console.log("  telegram <token>    — configure telegram");
     console.log("  slack <bot> <app>   — configure slack");

package/src/db/models/session.ts

@@ -1,5 +1,14 @@
 import { getSql } from "../connection";
 
+export interface SessionSummary {
+  id: string;
+  room: string;
+  createdAt: string;
+  updatedAt: string;
+  preview: string | null;
+  messageCount: number;
+}
+
 export async function getLatest(room: string): Promise<string | null> {
   const sql = getSql();
   const rows = await sql`
@@ -11,6 +20,35 @@ export async function getLatest(room: string): Promise<string | null> {
   return rows.length > 0 ? rows[0].id : null;
 }
 
+export async function getRecent(room: string, limit = 10): Promise<SessionSummary[]> {
+  const sql = getSql();
+  const rows = await sql`
+    SELECT
+      s.id,
+      s.room,
+      s.created_at,
+      s.updated_at,
+      (
+        SELECT content FROM messages m
+        WHERE m.session_id = s.id AND m.sender = 'user'
+        ORDER BY m.created_at ASC LIMIT 1
+      ) AS preview,
+      (SELECT COUNT(*)::int FROM messages m WHERE m.session_id = s.id) AS message_count
+    FROM sessions s
+    WHERE s.room = ${room}
+    ORDER BY s.updated_at DESC
+    LIMIT ${limit}
+  `;
+  return rows.map((r) => ({
+    id: r.id,
+    room: r.room,
+    createdAt: String(r.created_at),
+    updatedAt: String(r.updated_at),
+    preview: r.preview ? String(r.preview) : null,
+    messageCount: r.message_count,
+  }));
+}
+
 export async function create(id: string, room: string): Promise<void> {
   const sql = getSql();
   await sql`INSERT INTO sessions (id, room) VALUES (${id}, ${room})`;

package/src/prompts/channel-common.md

@@ -0,0 +1,17 @@
+## Channel: Common
+
+These rules apply to all non-terminal channels (Telegram, Slack, etc).
+
+### Output visibility
+- The user does NOT see raw command outputs or tool results — only your final response.
+- When you run commands, relay the important details or summarize key results so the user understands what happened.
+- Never say "see the output above" — there is no output visible to them.
+
+### Brevity
+- Channel messages should be concise. Default to short replies unless the user asks for detail.
+- Do not narrate abstractly. Explain what you are doing and why, briefly.
+- If you weren't able to do something (e.g. a command failed), tell the user directly.
+
+### Files & media
+- Never tell the user to "save this file" or "copy this output" — you share the same filesystem.
+- Use `send_message` with `media_path` to share images or files directly in the channel.

package/src/prompts/environment.md

@@ -45,6 +45,7 @@ Config reference:
 - `active_hours.start` / `active_hours.end` — HH:MM window when jobs run
 - `log_level` — daemon log verbosity
 - `gemini_api_key` — Gemini API key for image generation
+- `openai_api_key` — OpenAI API key for image generation
 - `channels.enabled` — enable/disable all channels (set false on dev machines)
 - `channels.default` — which channel send_message uses by default
 - `channels.telegram.bot_token` — Telegram bot API token

package/src/prompts/index.ts

@@ -39,5 +39,13 @@ export function getModePrompt(mode: Mode): string {
 }
 
 export function getChannelPrompt(channel: string): string {
-  return loadPrompt(`channel-${channel}.md`);
+  const parts: string[] = [];
+  // Load common channel rules for non-terminal channels
+  if (channel !== "terminal") {
+    const common = loadPrompt("channel-common.md");
+    if (common) parts.push(common);
+  }
+  const specific = loadPrompt(`channel-${channel}.md`);
+  if (specific) parts.push(specific);
+  return parts.join("\n\n");
 }

package/src/prompts/mode-chat.md

@@ -1,2 +1,27 @@
 ## Mode: Chat
-You are in a live chat session. Be conversational, helpful, and concise. You can run shell commands to manage jobs, read files, or check system state.
+
+You are in a live chat session. Be conversational, helpful, and concise.
+
+### Response complexity
+- Match the complexity of your response to the task. Simple question → one-liner. Complex change → structured walkthrough.
+- For big or complex changes: state the solution first, then walk through what you did and why.
+- For casual chit-chat, just chat.
+
+### Review mindset
+- When the user asks for a review (code review, PR review, design review), prioritize identifying bugs, risks, regressions, and missing tests.
+- Present findings ordered by severity, with file or line references where possible.
+- Open questions or assumptions follow the findings.
+- If no issues found, say so explicitly and call out any residual risks or test gaps.
+
+### Options & next steps
+- When suggesting multiple options, use numeric lists so the user can respond with a single number.
+- Suggest natural next steps at the end of your response — but only when they genuinely exist.
+- Do not add filler like "Let me know if you need anything else!" or suggest next steps when there are none.
+
+### Git safety
+- You may be working in a dirty git worktree. NEVER revert existing changes you didn't make unless explicitly asked.
+- If asked to commit and there are unrelated changes, don't revert them — only commit your own work.
+- Do not amend commits unless explicitly asked.
+- If you notice unexpected changes you didn't make, STOP and ask the user how to proceed.
+- NEVER use destructive commands (`git reset --hard`, `git checkout --`) unless specifically requested.
+- Prefer non-interactive git commands.

package/src/prompts/mode-job.md

@@ -1,2 +1,8 @@
 ## Mode: Job
+
 You are executing a scheduled job. Be terse — execute the task and report the result. No small talk.
+
+- State the outcome first, then supporting details if needed.
+- If the job failed, report what went wrong clearly.
+- NEVER use destructive git commands unless the job prompt explicitly requires it.
+- Do not amend commits or revert changes you didn't make.

package/src/types/engine.ts

@@ -22,6 +22,7 @@ export interface ChatEngine {
 export interface EngineOptions {
   room: string;
   channel: string;
-  resume: boolean;
+  /** true = resume latest session, or pass a specific session ID */
+  resume: boolean | string;
   mcpServers?: Record<string, unknown>;
 }