niahere 0.2.30 → 0.2.32

package/package.json

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

package/src/chat/identity.ts

@@ -1,14 +1,12 @@
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { join, resolve } from "path";
-import { homedir } from "os";
-import yaml from "js-yaml";
-import { getNiaHome, getPaths } from "../utils/paths";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { getPaths } from "../utils/paths";
 import { getEnvironmentPrompt, getModePrompt, getChannelPrompt } from "../prompts";
-import { log } from "../utils/log";
+import { getSkillsSummary } from "../core/skills";
 import type { Mode } from "../types";
 
-// niahere project root (resolved from this file's location)
-const PROJECT_ROOT = resolve(import.meta.dir, "../..");
+// Re-export for backwards compat
+export { scanSkills as loadSkills, getSkillNames as loadSkillNames, type SkillInfo } from "../core/skills";
 
 function loadFile(dir: string, name: string): string {
   const filePath = join(dir, name);
@@ -22,71 +20,6 @@ export function loadIdentity(): string {
   return files.map((f) => loadFile(selfDir, f)).filter(Boolean).join("\n\n");
 }
 
-function scanSkills(): { name: string; description: string }[] {
-  const home = homedir();
-  const cwd = process.cwd();
-  const niaHome = getNiaHome();
-  const skillDirs = [
-    join(cwd, "skills"),
-    join(PROJECT_ROOT, "skills"),
-    join(niaHome, "skills"),
-    join(home, ".shared", "skills"),
-    join(home, ".claude", "skills"),
-    join(home, ".codex", "skills"),
-  ];
-
-  const skills: { name: string; description: string }[] = [];
-  const seen = new Set<string>();
-
-  for (const dir of skillDirs) {
-    if (!existsSync(dir)) continue;
-
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-
-      const skillFile = join(dir, entry.name, "SKILL.md");
-      if (!existsSync(skillFile)) continue;
-
-      const content = readFileSync(skillFile, "utf8");
-      const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-      if (!fmMatch) continue;
-
-      let meta: Record<string, unknown> = {};
-      try {
-        meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
-      } catch (err) {
-        log.warn({ err, skill: entry.name, path: skillFile }, "failed to parse skill metadata, skipping");
-        continue;
-      }
-      const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
-
-      if (seen.has(name)) continue;
-      seen.add(name);
-
-      skills.push({
-        name,
-        description: typeof meta.description === "string" ? meta.description : "",
-      });
-    }
-  }
-
-  return skills;
-}
-
-export function loadSkillNames(): string[] {
-  return scanSkills().map((s) => s.name);
-}
-
-export function loadSkillsSummary(): string {
-  const skills = scanSkills();
-  if (skills.length === 0) return "";
-
-  const lines = skills.map((s) =>
-    s.description ? `- /${s.name}: ${s.description}` : `- /${s.name}`,
-  );
-  return `Available skills:\n${lines.join("\n")}`;
-}
-
 export function buildSystemPrompt(mode: Mode = "chat", channel: string = "terminal"): string {
   const parts: string[] = [];
 
@@ -101,7 +34,7 @@ export function buildSystemPrompt(mode: Mode = "chat", channel: string = "termin
   const channelPrompt = getChannelPrompt(channel);
   if (channelPrompt) parts.push(channelPrompt);
 
-  const skills = loadSkillsSummary();
+  const skills = getSkillsSummary();
   if (skills) parts.push(skills);
 
   return parts.join("\n\n");

package/src/cli/index.ts

@@ -287,12 +287,19 @@ switch (command) {
   }
 
   case "skills": {
-    const { loadSkillNames } = await import("../chat/identity");
-    const names = loadSkillNames();
-    if (names.length === 0) {
-      console.log("No skills found.");
+    const { scanSkills: loadSkills } = await import("../core/skills");
+    const filter = process.argv[3]; // e.g. "project", "nia", "shared", "claude"
+    let skills = loadSkills();
+    if (filter) {
+      skills = skills.filter((s) => s.source === filter);
+    }
+    if (skills.length === 0) {
+      console.log(filter ? `No skills found in "${filter}".` : "No skills found.");
     } else {
-      for (const name of names) console.log(`  ${name}`);
+      for (const s of skills) {
+        const tag = filter ? "" : `  [${s.source}]`;
+        console.log(`  ${s.name}${tag}`);
+      }
     }
     break;
   }
@@ -424,6 +431,38 @@ switch (command) {
     process.exit(result.ok ? 0 : 1);
   }
 
+  case "update": {
+    const { version: currentVersion } = await import("../../package.json");
+    console.log(`Current: v${currentVersion}`);
+    console.log("Updating...");
+    const install = Bun.spawn(["npm", "i", "-g", "niahere@latest"], { stdio: ["ignore", "inherit", "inherit"] });
+    const installExit = await install.exited;
+    if (installExit !== 0) {
+      fail("Update failed.");
+    }
+    // Get new version
+    const check = Bun.spawn(["npm", "view", "niahere", "version"], { stdout: "pipe", stderr: "pipe" });
+    const newVersion = (await new Response(check.stdout).text()).trim();
+    await check.exited;
+    if (newVersion === currentVersion) {
+      console.log("Already on latest.");
+    } else {
+      console.log(`Updated: v${currentVersion} → v${newVersion}`);
+      if (isRunning()) {
+        console.log("Restarting daemon...");
+        const { isServiceInstalled, restartService } = await import("../commands/service");
+        if (isServiceInstalled()) {
+          await restartService();
+        } else {
+          stopDaemon();
+          startDaemon();
+        }
+        console.log("Restarted.");
+      }
+    }
+    break;
+  }
+
   case "init": {
     const { runInit } = await import("../commands/init");
     await runInit();
@@ -432,6 +471,7 @@ switch (command) {
 
   default:
     console.log("Usage: nia <command>\n");
+    console.log("  update              — update to latest version and restart");
     console.log("  init                — setup nia");
     console.log("  start / stop        — daemon + service control");
     console.log("  restart             — restart daemon");

package/src/commands/health.ts

@@ -1,107 +1,6 @@
-import { existsSync, statSync } from "fs";
-import { join } from "path";
-import { isRunning, readPid } from "../core/daemon";
-import { getConfig, readRawConfig } from "../utils/config";
-import { getPaths } from "../utils/paths";
-import { errMsg } from "../utils/errors";
-import { localTime } from "../utils/time";
-
-type Check = { name: string; status: "ok" | "warn" | "fail"; detail: string };
-
-function push(checks: Check[], name: string, status: Check["status"], detail: string): void {
-  checks.push({ name, status, detail });
-}
+import { runHealthChecks } from "../core/health";
 
 export async function healthCommand(): Promise<void> {
-  const checks: Check[] = [];
-  const paths = getPaths();
-
-  // 0. Version
-  const { version } = await import("../../package.json");
-  push(checks, "nia", "ok", "v" + version);
-
-  // 1. Daemon
-  const pid = readPid();
-  if (isRunning()) {
-    push(checks, "daemon", "ok", "running (pid: " + pid + ")");
-  } else if (pid) {
-    push(checks, "daemon", "fail", "stale pid file (pid: " + pid + ", not running)");
-  } else {
-    push(checks, "daemon", "warn", "not running");
-  }
-
-  // 2. Config
-  if (existsSync(paths.config)) {
-    const raw = readRawConfig();
-    push(checks, "config", "ok", Object.keys(raw).length + " keys loaded");
-  } else {
-    push(checks, "config", "fail", "missing (" + paths.config + ")");
-  }
-
-  // 3. Database
-  try {
-    const config = getConfig();
-    if (!config.database_url || !config.database_url.startsWith("postgres")) {
-      push(checks, "database", "fail", 'invalid url: "' + (config.database_url || "(empty)") + '"');
-    } else {
-      const { checkDbHealth } = await import("./health-db");
-      const ok = await checkDbHealth(config.database_url);
-      push(checks, "database", ok ? "ok" : "fail", config.database_url.replace(/\/\/.*@/, "//***@"));
-    }
-  } catch (err) {
-    push(checks, "database", "fail", errMsg(err));
-  }
-
-  // 4. Channels
-  const config = getConfig();
-  if (!config.channels.enabled) {
-    push(checks, "channels", "warn", "disabled");
-  } else {
-    const chans: string[] = [];
-    if (config.channels.telegram.bot_token) chans.push("telegram");
-    if (config.channels.slack.bot_token && config.channels.slack.app_token) chans.push("slack");
-    if (chans.length > 0) {
-      push(checks, "channels", "ok", "configured: " + chans.join(", "));
-    } else {
-      push(checks, "channels", "warn", "enabled but no tokens configured");
-    }
-  }
-
-  // 5. API keys
-  const geminiKey = config.gemini_api_key;
-  const rawConfig = readRawConfig();
-  const openaiKey = typeof rawConfig.openai_api_key === "string" ? rawConfig.openai_api_key : null;
-  const apiKeys: string[] = [];
-  if (geminiKey) apiKeys.push("gemini");
-  if (openaiKey) apiKeys.push("openai");
-  push(checks, "api keys", apiKeys.length > 0 ? "ok" : "warn",
-    apiKeys.length > 0 ? apiKeys.join(", ") : "none configured");
-
-  // 6. Persona files
-  const personaFiles = ["identity.md", "owner.md", "soul.md"];
-  const missing = personaFiles.filter((f) => !existsSync(join(paths.selfDir, f)));
-  if (missing.length === 0) {
-    push(checks, "persona", "ok", "all files present");
-  } else {
-    push(checks, "persona", "warn", "missing: " + missing.join(", "));
-  }
-
-  // 7. Daemon log
-  if (existsSync(paths.daemonLog)) {
-    const stat = statSync(paths.daemonLog);
-    const sizeMb = (stat.size / 1024 / 1024).toFixed(1);
-    const lastMod = localTime(stat.mtime);
-    push(checks, "logs", stat.size > 100 * 1024 * 1024 ? "warn" : "ok",
-      sizeMb + " MB, last write: " + lastMod);
-  } else {
-    push(checks, "logs", "warn", "no log file");
-  }
-
-  // 8. Bun version
-  const bunVersion = typeof Bun !== "undefined" ? Bun.version : "unknown";
-  push(checks, "bun", "ok", "v" + bunVersion);
-
-  // Output
   const { GREEN, YELLOW, RED, RESET, ICON_PASS, ICON_FAIL, ICON_WARN } = await import("../utils/cli");
   const icons: Record<string, string> = {
     ok: GREEN + ICON_PASS + RESET,
@@ -109,6 +8,8 @@ export async function healthCommand(): Promise<void> {
     fail: RED + ICON_FAIL + RESET,
   };
 
+  const checks = await runHealthChecks();
+
   console.log();
   for (const c of checks) {
     console.log("  " + icons[c.status] + " " + c.name.padEnd(12) + " " + c.detail);

package/src/core/alive.ts

@@ -1,24 +1,15 @@
 import { log } from "../utils/log";
 import { getConfig } from "../utils/config";
 import { getSql, closeDb } from "../db/connection";
+import { getFailures, type Check } from "./health";
 
 const HEARTBEAT_INTERVAL = 60_000; // 60s
 
 let timer: ReturnType<typeof setInterval> | null = null;
-let consecutiveFailures = 0;
+let lastFailures: string[] = [];
 let recoveryAttempted = false;
 
-async function checkDb(): Promise<boolean> {
-  try {
-    const sql = getSql();
-    await sql`SELECT 1`;
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function attemptReconnect(): Promise<boolean> {
+async function attemptDbReconnect(): Promise<boolean> {
   try {
     await closeDb();
     const sql = getSql();
@@ -33,7 +24,6 @@ async function attemptReconnect(): Promise<boolean> {
 async function notifyUser(message: string): Promise<void> {
   const config = getConfig();
 
-  // Try Telegram first
   const tgToken = config.channels.telegram.bot_token;
   const tgChatId = config.channels.telegram.chat_id;
   if (tgToken && tgChatId) {
@@ -48,7 +38,6 @@ async function notifyUser(message: string): Promise<void> {
     }
   }
 
-  // Fall back to Slack
   const slToken = config.channels.slack.bot_token;
   const slRecipient = config.channels.slack.dm_user_id || config.channels.slack.channel_id;
   if (slToken && slRecipient) {
@@ -70,37 +59,39 @@ async function notifyUser(message: string): Promise<void> {
   log.error("alive: could not notify user — no channel available");
 }
 
-/** Run an LLM recovery agent to diagnose and fix the issue. */
-async function runRecoveryAgent(error: string): Promise<{ recovered: boolean; report: string }> {
+/** Run LLM recovery agent for failures it can fix (e.g. DB down). */
+async function runRecoveryAgent(failures: Check[]): Promise<{ recovered: boolean; report: string }> {
   try {
     const { runJobWithClaude } = await import("./runner");
     const { homedir } = await import("os");
 
+    const failureSummary = failures.map((f) => `- ${f.name}: ${f.detail}`).join("\n");
+
     const systemPrompt = [
       "You are a system recovery agent for the Nia daemon.",
-      "The database connection just failed and reconnect didn't work.",
-      "Your job: diagnose the issue, attempt to fix it, and report the outcome.",
+      "Health checks detected failures. Diagnose and fix what you can.",
+      "",
+      "For database issues:",
+      "1. Check: pg_isready, brew services list (macOS), systemctl status postgresql (Linux)",
+      "2. Fix: brew services start postgresql@17 (macOS) or systemctl start postgresql (Linux)",
+      "3. Verify: psql -d niahere -c 'SELECT 1'",
       "",
-      "Steps:",
-      "1. Check if PostgreSQL is running: pg_isready, brew services list (macOS), systemctl status postgresql (Linux)",
-      "2. If stopped, try to start it: brew services start postgresql@17 (macOS) or systemctl start postgresql (Linux)",
-      "3. Wait a few seconds, then verify connectivity: psql -d niahere -c 'SELECT 1'",
-      "4. If it's a different issue (disk space, permissions, etc), diagnose and report",
+      "For other issues: diagnose, attempt fix if safe, report findings.",
       "",
       "Respond with a brief postmortem:",
       "- What was wrong",
-      "- What you did to fix it",
-      "- Whether it's recovered or still failing",
-      "- Any recommendations",
+      "- What you did",
+      "- Current status",
     ].join("\n");
 
-    const jobPrompt = `Database is unreachable. Reconnect failed.\nError: ${error}\n\nDiagnose and fix.`;
+    const jobPrompt = `Health check failures:\n${failureSummary}\n\nDiagnose and fix.`;
 
     const result = await runJobWithClaude(systemPrompt, jobPrompt, homedir());
-    const recovered = await checkDb();
 
+    // Re-check after recovery attempt
+    const remaining = await getFailures();
     return {
-      recovered,
+      recovered: remaining.length === 0,
       report: result.agentText || "Recovery agent returned no output.",
     };
   } catch (err) {
@@ -112,58 +103,60 @@ async function runRecoveryAgent(error: string): Promise<{ recovered: boolean; re
 }
 
 async function heartbeat(): Promise<void> {
-  const ok = await checkDb();
-
-  if (ok) {
-    if (consecutiveFailures > 0) {
-      log.info({ previousFailures: consecutiveFailures }, "alive: database recovered");
-      await notifyUser(`Database recovered after ~${consecutiveFailures} min of downtime.`);
+  const failures = await getFailures();
+  const failureNames = failures.map((f) => f.name);
+
+  // All clear
+  if (failures.length === 0) {
+    if (lastFailures.length > 0) {
+      log.info({ recovered: lastFailures }, "alive: all checks passing");
+      await notifyUser(`Recovered: ${lastFailures.join(", ")} back to normal.`);
     }
-    consecutiveFailures = 0;
+    lastFailures = [];
     recoveryAttempted = false;
     return;
   }
 
-  consecutiveFailures++;
-  log.warn({ consecutiveFailures }, "alive: database unreachable");
+  // New failures detected
+  const newFailures = failureNames.filter((f) => !lastFailures.includes(f));
+  if (newFailures.length > 0) {
+    log.warn({ failures: failureNames }, "alive: health check failures detected");
+  }
 
-  // Try reconnect
-  const reconnected = await attemptReconnect();
-  if (reconnected) {
-    log.info("alive: reconnected to database");
-    if (consecutiveFailures > 1) {
-      await notifyUser(`Database reconnected after ~${consecutiveFailures} min.`);
+  // Try DB reconnect if database is failing
+  if (failureNames.includes("database")) {
+    const reconnected = await attemptDbReconnect();
+    if (reconnected) {
+      log.info("alive: database reconnected");
+      // Re-check everything
+      const remaining = await getFailures();
+      if (remaining.length === 0) {
+        lastFailures = [];
+        recoveryAttempted = false;
+        return;
+      }
     }
-    consecutiveFailures = 0;
-    recoveryAttempted = false;
-    return;
   }
 
-  // Reconnect failed — run recovery agent immediately (once per outage)
+  // Run recovery agent once per outage
   if (!recoveryAttempted) {
     recoveryAttempted = true;
-    log.info("alive: reconnect failed, running recovery agent");
+    log.info({ failures: failureNames }, "alive: running recovery agent");
 
-    const { recovered, report } = await runRecoveryAgent(
-      "PostgreSQL unreachable, reconnect failed after " + consecutiveFailures + " heartbeat(s)"
-    );
+    const { recovered, report } = await runRecoveryAgent(failures);
 
     if (recovered) {
-      log.info("alive: recovery agent succeeded");
-      await notifyUser(`Database was down. Recovery agent fixed it.\n\n${report}`);
-      consecutiveFailures = 0;
+      log.info({ report }, "alive: recovery agent succeeded");
+      await notifyUser(report);
+      lastFailures = [];
       recoveryAttempted = false;
     } else {
-      log.error("alive: recovery failed, notifying user");
-      await notifyUser(
-        `Database is down and auto-recovery failed.\n\n` +
-        `Recovery report:\n${report}\n\n` +
-        `Run \`nia health\` to check status.`
-      );
+      log.error({ report }, "alive: recovery failed, notifying user");
+      await notifyUser(report);
     }
   }
-  // After recovery attempted: just log failures, don't spam user or agent.
-  // When DB comes back, the ok branch above will notify.
+
+  lastFailures = failureNames;
 }
 
 export function startAlive(): void {

package/src/core/health.ts

@@ -0,0 +1,145 @@
+import { existsSync, statSync } from "fs";
+import { join } from "path";
+import { getConfig, readRawConfig } from "../utils/config";
+import { getPaths } from "../utils/paths";
+import { isRunning, readPid } from "./daemon";
+import { errMsg } from "../utils/errors";
+import { localTime } from "../utils/time";
+
+export type CheckStatus = "ok" | "warn" | "fail";
+export type Check = { name: string; status: CheckStatus; detail: string };
+
+/** Run all health checks. Returns structured results usable by CLI and alive monitor. */
+export async function runHealthChecks(): Promise<Check[]> {
+  const checks: Check[] = [];
+  const paths = getPaths();
+  const config = getConfig();
+
+  // Version
+  const { version } = await import("../../package.json");
+  checks.push({ name: "nia", status: "ok", detail: "v" + version });
+
+  // Daemon
+  const pid = readPid();
+  if (isRunning()) {
+    checks.push({ name: "daemon", status: "ok", detail: "running (pid: " + pid + ")" });
+  } else if (pid) {
+    checks.push({ name: "daemon", status: "fail", detail: "stale pid file (pid: " + pid + ", not running)" });
+  } else {
+    checks.push({ name: "daemon", status: "warn", detail: "not running" });
+  }
+
+  // Config
+  if (existsSync(paths.config)) {
+    const raw = readRawConfig();
+    checks.push({ name: "config", status: "ok", detail: Object.keys(raw).length + " keys loaded" });
+  } else {
+    checks.push({ name: "config", status: "fail", detail: "missing (" + paths.config + ")" });
+  }
+
+  // Database
+  try {
+    if (!config.database_url || !config.database_url.startsWith("postgres")) {
+      checks.push({ name: "database", status: "fail", detail: 'invalid url: "' + (config.database_url || "(empty)") + '"' });
+    } else {
+      const { checkDbHealth } = await import("../commands/health-db");
+      const ok = await checkDbHealth(config.database_url);
+      checks.push({ name: "database", status: ok ? "ok" : "fail", detail: ok ? "connected" : "unreachable" });
+    }
+  } catch (err) {
+    checks.push({ name: "database", status: "fail", detail: errMsg(err) });
+  }
+
+  // Channels — check actual connectivity, not just config
+  if (!config.channels.enabled) {
+    checks.push({ name: "channels", status: "warn", detail: "disabled" });
+  } else {
+    const results: string[] = [];
+
+    // Telegram
+    const tgToken = config.channels.telegram.bot_token;
+    if (tgToken) {
+      try {
+        const resp = await fetch(`https://api.telegram.org/bot${tgToken}/getMe`);
+        const data = await resp.json() as { ok: boolean };
+        results.push(data.ok ? "telegram: connected" : "telegram: auth failed");
+        if (!data.ok) checks.push({ name: "telegram", status: "fail", detail: "auth failed" });
+      } catch {
+        results.push("telegram: unreachable");
+        checks.push({ name: "telegram", status: "fail", detail: "unreachable" });
+      }
+    }
+
+    // Slack
+    const slToken = config.channels.slack.bot_token;
+    if (slToken) {
+      try {
+        const resp = await fetch("https://slack.com/api/auth.test", {
+          method: "POST",
+          headers: { Authorization: `Bearer ${slToken}`, "Content-Type": "application/json" },
+        });
+        const data = await resp.json() as { ok: boolean; error?: string };
+        results.push(data.ok ? "slack: connected" : `slack: ${data.error || "auth failed"}`);
+        if (!data.ok) checks.push({ name: "slack", status: "fail", detail: data.error || "auth failed" });
+      } catch {
+        results.push("slack: unreachable");
+        checks.push({ name: "slack", status: "fail", detail: "unreachable" });
+      }
+    }
+
+    if (results.length === 0) {
+      checks.push({ name: "channels", status: "warn", detail: "enabled but no tokens configured" });
+    } else {
+      const allOk = results.every((r) => r.includes("connected"));
+      checks.push({ name: "channels", status: allOk ? "ok" : "warn", detail: results.join(", ") });
+    }
+  }
+
+  // API keys
+  const geminiKey = config.gemini_api_key;
+  const rawConfig = readRawConfig();
+  const openaiKey = typeof rawConfig.openai_api_key === "string" ? rawConfig.openai_api_key : null;
+  const apiKeys: string[] = [];
+  if (geminiKey) apiKeys.push("gemini");
+  if (openaiKey) apiKeys.push("openai");
+  checks.push({
+    name: "api keys",
+    status: apiKeys.length > 0 ? "ok" : "warn",
+    detail: apiKeys.length > 0 ? apiKeys.join(", ") : "none configured",
+  });
+
+  // Persona files
+  const personaFiles = ["identity.md", "owner.md", "soul.md"];
+  const missing = personaFiles.filter((f) => !existsSync(join(paths.selfDir, f)));
+  checks.push({
+    name: "persona",
+    status: missing.length === 0 ? "ok" : "warn",
+    detail: missing.length === 0 ? "all files present" : "missing: " + missing.join(", "),
+  });
+
+  // Daemon log
+  if (existsSync(paths.daemonLog)) {
+    const stat = statSync(paths.daemonLog);
+    const sizeMb = (stat.size / 1024 / 1024).toFixed(1);
+    const lastMod = localTime(stat.mtime);
+    checks.push({
+      name: "logs",
+      status: stat.size > 100 * 1024 * 1024 ? "warn" : "ok",
+      detail: sizeMb + " MB, last write: " + lastMod,
+    });
+  } else {
+    checks.push({ name: "logs", status: "warn", detail: "no log file" });
+  }
+
+  // Bun version
+  const bunVersion = typeof Bun !== "undefined" ? Bun.version : "unknown";
+  checks.push({ name: "bun", status: "ok", detail: "v" + bunVersion });
+
+  return checks;
+}
+
+/** Quick check — returns just the failures. Used by alive monitor. */
+export async function getFailures(): Promise<Check[]> {
+  const checks = await runHealthChecks();
+  return checks.filter((c) => c.status === "fail");
+}

package/src/core/skills.ts

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+import yaml from "js-yaml";
+import { getNiaHome } from "../utils/paths";
+import { log } from "../utils/log";
+
+// niahere project root (resolved from this file's location)
+const PROJECT_ROOT = resolve(import.meta.dir, "../..");
+
+export type SkillInfo = { name: string; description: string; source: string };
+
+const SKILL_DIRS: { dir: string; source: string }[] = [
+  { dir: join(process.cwd(), "skills"), source: "cwd" },
+  { dir: join(PROJECT_ROOT, "skills"), source: "project" },
+  { dir: join(getNiaHome(), "skills"), source: "nia" },
+  { dir: join(homedir(), ".shared", "skills"), source: "shared" },
+  { dir: join(homedir(), ".claude", "skills"), source: "claude" },
+  { dir: join(homedir(), ".codex", "skills"), source: "codex" },
+];
+
+export function scanSkills(): SkillInfo[] {
+  const skills: SkillInfo[] = [];
+  const seen = new Set<string>();
+
+  for (const { dir, source } of SKILL_DIRS) {
+    if (!existsSync(dir)) continue;
+
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+
+      const skillFile = join(dir, entry.name, "SKILL.md");
+      if (!existsSync(skillFile)) continue;
+
+      const content = readFileSync(skillFile, "utf8");
+      const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!fmMatch) continue;
+
+      let meta: Record<string, unknown> = {};
+      try {
+        meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
+      } catch (err) {
+        log.warn({ err, skill: entry.name, path: skillFile }, "failed to parse skill metadata, skipping");
+        continue;
+      }
+      const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
+
+      if (seen.has(name)) continue;
+      seen.add(name);
+
+      skills.push({ name, description: typeof meta.description === "string" ? meta.description : "", source });
+    }
+  }
+
+  return skills;
+}
+
+export function getSkillNames(): string[] {
+  return scanSkills().map((s) => s.name);
+}
+
+export function getSkillsSummary(): string {
+  const skills = scanSkills();
+  if (skills.length === 0) return "";
+  const lines = skills.map((s) => s.description ? `- /${s.name}: ${s.description}` : `- /${s.name}`);
+  return `Available skills:\n${lines.join("\n")}`;
+}