lituanic 0.1.0

package/src/index.ts

@@ -0,0 +1,201 @@
+import { createServer, type Server } from "node:http";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig, defineConfig, type LituanicConfig } from "./config.js";
+import {
+  createSlackApp,
+  wireSlack,
+  startWebhookServer,
+  startHeartbeats,
+  type IncomingEvent,
+} from "./gateway.js";
+import { think, type ThinkResult } from "./think.js";
+import { createMemoryManager } from "./memory.js";
+import { createSessionStore } from "./sessions.js";
+import type { Cron } from "croner";
+
+export { defineConfig, loadConfig, type LituanicConfig };
+export { type IncomingEvent } from "./gateway.js";
+export { type MemoryManager, createMemoryManager } from "./memory.js";
+export { type SessionStore, createSessionStore } from "./sessions.js";
+
+const pkg = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf-8"));
+
+interface LituanicDaemon {
+  config: LituanicConfig;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+
+export function createDaemon(config: LituanicConfig): LituanicDaemon {
+  let running = false;
+  let startTime = 0;
+  const memory = createMemoryManager(config.data);
+  const sessions = createSessionStore(config.data);
+  const slackApp = createSlackApp(config);
+
+  // Track resources for graceful shutdown
+  let healthServer: Server | undefined;
+  let webhookServer: Server | undefined;
+  let crons: Cron[] = [];
+  let lastEvent: string | null = null;
+  let activeSessions = 0;
+
+  async function handleMessage(event: IncomingEvent): Promise<void> {
+    if (!running) return; // reject events during shutdown
+
+    lastEvent = new Date().toISOString();
+    activeSessions++;
+
+    // Typing indicator
+    let typingTs: string | undefined;
+    if (slackApp && event.channelId) {
+      try {
+        const msg = await slackApp.client.chat.postMessage({
+          channel: event.channelId,
+          thread_ts: event.threadTs,
+          text: ":hourglass_flowing_sand: Working...",
+        });
+        typingTs = msg.ts as string;
+      } catch {}
+    }
+
+    try {
+      const result: ThinkResult = await think({
+        config,
+        event,
+        memory,
+        sessions,
+        slack: slackApp,
+        onNotification: slackApp && config.slack?.channel
+          ? (message) => {
+              slackApp.client.chat.postMessage({
+                channel: config.slack!.channel!,
+                text: `[notification] ${message}`,
+              }).catch(() => {});
+            }
+          : undefined,
+        onProgress: slackApp && event.channelId && typingTs
+          ? (text) => {
+              slackApp.client.chat.update({
+                channel: event.channelId!,
+                ts: typingTs!,
+                text: `:hourglass_flowing_sand: ${text}...`,
+              }).catch(() => {});
+            }
+          : undefined,
+      });
+
+      // Delete typing indicator
+      if (slackApp && event.channelId && typingTs) {
+        try { await slackApp.client.chat.delete({ channel: event.channelId, ts: typingTs }); } catch {}
+      }
+
+      if (slackApp && event.channelId && result.response) {
+        if (result.response.startsWith("[SILENT]")) return;
+        await slackApp.client.chat.postMessage({
+          channel: event.channelId,
+          thread_ts: event.threadTs,
+          text: result.response,
+          blocks: [{ type: "markdown", text: result.response }],
+        });
+      }
+    } catch (err) {
+      console.error("[lituanic] Error:", err);
+      if (slackApp && event.channelId && typingTs) {
+        try { await slackApp.client.chat.delete({ channel: event.channelId, ts: typingTs }); } catch {}
+      }
+      if (slackApp && config.slack?.channel) {
+        try {
+          await slackApp.client.chat.postMessage({
+            channel: config.slack.channel,
+            text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+          });
+        } catch {}
+      }
+    } finally {
+      activeSessions--;
+    }
+  }
+
+  return {
+    config,
+
+    async start() {
+      if (running) return;
+      running = true;
+      startTime = Date.now();
+
+      console.log(`[lituanic] Starting ${config.name} v${pkg.version}...`);
+
+      if (slackApp) {
+        wireSlack(slackApp, handleMessage);
+        await slackApp.start();
+        console.log("[lituanic] Slack connected (Socket Mode)");
+      }
+
+      webhookServer = startWebhookServer(config, handleMessage) ?? undefined;
+
+      crons = startHeartbeats(config, handleMessage);
+      if (crons.length > 0) console.log(`[lituanic] ${crons.length} heartbeats active`);
+
+      healthServer = createServer((req, res) => {
+        if (req.url === config.health.endpoint) {
+          res.writeHead(200, { "Content-Type": "application/json", "Server": `Lituanic/${pkg.version}` });
+          res.end(JSON.stringify({
+            status: "ok",
+            name: config.name,
+            since: 1009,
+            uptime: Math.floor((Date.now() - startTime) / 1000),
+            lastEvent,
+            activeSessions,
+            version: pkg.version,
+          }));
+        } else {
+          res.writeHead(404);
+          res.end();
+        }
+      });
+
+      healthServer.listen(config.health.port, () => {
+        console.log(`[lituanic] Health: http://localhost:${config.health.port}${config.health.endpoint}`);
+      });
+
+      console.log(`[lituanic] ${config.name} is live.`);
+    },
+
+    async stop() {
+      if (!running) return;
+      running = false;
+      console.log(`[lituanic] Shutting down ${config.name}...`);
+
+      // Stop accepting new events
+      for (const cron of crons) cron.stop();
+      healthServer?.close();
+      webhookServer?.close();
+
+      // Wait for active sessions to drain (max 30s)
+      if (activeSessions > 0) {
+        console.log(`[lituanic] Waiting for ${activeSessions} active session(s)...`);
+        const deadline = Date.now() + 30_000;
+        while (activeSessions > 0 && Date.now() < deadline) {
+          await new Promise((r) => setTimeout(r, 500));
+        }
+        if (activeSessions > 0) {
+          console.warn(`[lituanic] Force shutdown with ${activeSessions} active session(s)`);
+        }
+      }
+
+      // Stop Slack
+      if (slackApp) {
+        try { await slackApp.stop(); } catch {}
+      }
+
+      console.log(`[lituanic] ${config.name} stopped.`);
+      process.exit(0);
+    },
+  };
+}
+
+process.on("unhandledRejection", (err) => console.error("[lituanic] Unhandled rejection:", err));
+process.on("uncaughtException", (err) => { console.error("[lituanic] Uncaught exception:", err); process.exit(1); });

package/src/init.ts

@@ -0,0 +1,158 @@
+import { existsSync, mkdirSync, writeFileSync, cpSync } from "node:fs";
+import { join } from "node:path";
+
+const AGENT_IDENTITY = `# Agent Identity
+
+You are an AI coworker — not an assistant. You work autonomously, make decisions,
+and report results. You have your own accounts, memory, and tools.
+
+## How you work
+
+- Check Linear for assigned issues and work on them without being asked.
+- When you finish work, update the issue status and comment with a summary.
+- Use Slack to communicate results, ask for approvals, and report blockers.
+- Write daily logs to data/memory/ so you remember what you did.
+- When working on code: read first, understand, then change. Run tests.
+
+## Rules
+
+- Never deploy to production without approval.
+- Never post secrets, tokens, or API keys to Slack.
+- Keep Slack messages concise — bullet points, not essays.
+- When unsure, ask in Slack rather than guessing.
+- Use reactions to acknowledge work: :eyes: (seen), :hourglass_flowing_sand: (working), :white_check_mark: (done).
+`;
+
+const CONFIG_TEMPLATE = `import { defineConfig } from "lituanic";
+
+export default defineConfig({
+  name: "{{NAME}}",
+
+  // Slack — set env vars or configure here
+  // slack: {
+  //   botToken: process.env.SLACK_BOT_TOKEN!,
+  //   appToken: process.env.SLACK_APP_TOKEN!,
+  //   channel: "C0123456789", // ops channel
+  // },
+
+  // Uncomment to enable Linear webhooks
+  // webhook: {
+  //   port: 9100,
+  //   routes: {
+  //     "/webhook/linear": {
+  //       secret: process.env.LINEAR_WEBHOOK_SECRET,
+  //       verify: "hmac-sha256",
+  //     },
+  //   },
+  // },
+
+  // Uncomment to add scheduled tasks
+  // schedule: [
+  //   {
+  //     cron: "*/15 * * * *",
+  //     prompt: "Check Linear for assigned issues and work on them.",
+  //     timezone: "UTC",
+  //   },
+  // ],
+});
+`;
+
+const ENV_TEMPLATE = `# Required
+ANTHROPIC_API_KEY=
+
+# Slack (Socket Mode)
+SLACK_BOT_TOKEN=
+SLACK_APP_TOKEN=
+
+# Linear (optional)
+LINEAR_API_KEY=
+LINEAR_WEBHOOK_SECRET=
+
+# 1Password (optional — or use op run --env-file=.env.op)
+# OP_SERVICE_ACCOUNT_TOKEN=
+`;
+
+const MEMORY_TEMPLATE = `# Memory
+
+Agent memory will be written here during operation.
+`;
+
+export function init(name: string) {
+  const cwd = process.cwd();
+  const projectDir = name === "." ? cwd : join(cwd, name);
+
+  if (name !== "." && existsSync(projectDir)) {
+    console.error(`Directory "${name}" already exists.`);
+    process.exit(1);
+  }
+
+  console.log(`\nInitializing Lituanic agent: ${name === "." ? "current directory" : name}\n`);
+
+  // Create directories
+  const dirs = [
+    projectDir,
+    join(projectDir, ".claude", "skills"),
+    join(projectDir, "data", "memory"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+
+  // Copy built-in skills from package
+  const packageSkillsDir = join(import.meta.dir, "..", ".claude", "skills");
+  if (existsSync(packageSkillsDir)) {
+    cpSync(packageSkillsDir, join(projectDir, ".claude", "skills"), { recursive: true });
+    console.log("  copied .claude/skills/ (slack, linear, op, gws, browser, github)");
+  }
+
+  // Write agent identity
+  const claudeMd = join(projectDir, ".claude", "CLAUDE.md");
+  if (!existsSync(claudeMd)) {
+    writeFileSync(claudeMd, AGENT_IDENTITY);
+    console.log("  created .claude/CLAUDE.md (agent identity)");
+  }
+
+  // Write config
+  const configFile = join(projectDir, "lituanic.config.ts");
+  if (!existsSync(configFile)) {
+    writeFileSync(configFile, CONFIG_TEMPLATE.replace("{{NAME}}", name === "." ? "my-agent" : name));
+    console.log("  created lituanic.config.ts");
+  }
+
+  // Write .env
+  const envFile = join(projectDir, ".env");
+  if (!existsSync(envFile)) {
+    writeFileSync(envFile, ENV_TEMPLATE);
+    console.log("  created .env (fill in your tokens)");
+  }
+
+  // Write memory
+  const memoryFile = join(projectDir, "data", "memory", "MEMORY.md");
+  if (!existsSync(memoryFile)) {
+    writeFileSync(memoryFile, MEMORY_TEMPLATE);
+    console.log("  created data/memory/MEMORY.md");
+  }
+
+  // Write .gitignore if not exists
+  const gitignore = join(projectDir, ".gitignore");
+  if (!existsSync(gitignore)) {
+    writeFileSync(gitignore, `node_modules/\n.env\n.env.op\n*.log\ndata/memory/????-??-??.md\ndata/sessions/\ndata/*/MEMORY.md\n!data/memory/MEMORY.md\n`);
+    console.log("  created .gitignore");
+  }
+
+  console.log(`
+Done! Next steps:
+
+  1. Fill in your API keys:
+     ${name !== "." ? `cd ${name} && ` : ""}nano .env
+
+  2. Start the agent:
+     bun start
+
+  Or with 1Password:
+     op run --env-file=.env.op -- bun start
+
+  Check your setup:
+     bunx lituanic doctor
+`);
+}

package/src/memory.ts

@@ -0,0 +1,65 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface MemoryManager {
+  /** Read global MEMORY.md */
+  read(): string;
+  /** Write global MEMORY.md */
+  write(content: string): void;
+  /** Append to today's daily log */
+  appendDailyLog(entry: string): void;
+  /** Read today's daily log */
+  readDailyLog(): string;
+  /** Read per-channel memory */
+  readChannel(channelId: string): string;
+  /** Write per-channel memory */
+  writeChannel(channelId: string, content: string): void;
+}
+
+export function createMemoryManager(dataDir: string): MemoryManager {
+  const memoryDir = join(dataDir, "memory");
+  ensureDir(memoryDir);
+
+  function todayFile(): string {
+    const d = new Date();
+    const date = d.toISOString().split("T")[0];
+    return join(memoryDir, `${date}.md`);
+  }
+
+  return {
+    read() {
+      const p = join(memoryDir, "MEMORY.md");
+      return existsSync(p) ? readFileSync(p, "utf-8") : "";
+    },
+
+    write(content: string) {
+      writeFileSync(join(memoryDir, "MEMORY.md"), content, "utf-8");
+    },
+
+    appendDailyLog(entry: string) {
+      const p = todayFile();
+      const timestamp = new Date().toISOString().split("T")[1].slice(0, 5);
+      appendFileSync(p, `- ${timestamp} ${entry}\n`, "utf-8");
+    },
+
+    readDailyLog() {
+      const p = todayFile();
+      return existsSync(p) ? readFileSync(p, "utf-8") : "";
+    },
+
+    readChannel(channelId: string) {
+      const p = join(dataDir, channelId, "MEMORY.md");
+      return existsSync(p) ? readFileSync(p, "utf-8") : "";
+    },
+
+    writeChannel(channelId: string, content: string) {
+      const dir = join(dataDir, channelId);
+      ensureDir(dir);
+      writeFileSync(join(dir, "MEMORY.md"), content, "utf-8");
+    },
+  };
+}
+
+function ensureDir(dir: string) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}

package/src/sessions.ts

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+const SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+interface SessionEntry {
+  sessionId: string;
+  ts: number; // timestamp when stored
+}
+
+export interface SessionStore {
+  get(channelId: string, threadTs: string): string | undefined;
+  set(channelId: string, threadTs: string, sessionId: string): void;
+}
+
+export function createSessionStore(dataDir: string): SessionStore {
+  const dir = join(dataDir, "sessions");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const file = join(dir, "active.json");
+  let sessions: Record<string, SessionEntry> = {};
+  if (existsSync(file)) {
+    try {
+      const raw = JSON.parse(readFileSync(file, "utf-8"));
+      // Migrate from old format (plain string values) to new format (with timestamp)
+      for (const [key, val] of Object.entries(raw)) {
+        if (typeof val === "string") {
+          sessions[key] = { sessionId: val, ts: Date.now() };
+        } else if (val && typeof val === "object" && "sessionId" in (val as any)) {
+          sessions[key] = val as SessionEntry;
+        }
+      }
+    } catch {
+      console.warn("[lituanic] Corrupt sessions file, starting fresh");
+    }
+  }
+
+  function evict() {
+    const cutoff = Date.now() - SESSION_TTL_MS;
+    let evicted = 0;
+    for (const key of Object.keys(sessions)) {
+      if (sessions[key].ts < cutoff) {
+        delete sessions[key];
+        evicted++;
+      }
+    }
+    if (evicted > 0) console.log(`[lituanic] Evicted ${evicted} expired session(s)`);
+  }
+
+  function flush() {
+    writeFileSync(file, JSON.stringify(sessions, null, 2), "utf-8");
+  }
+
+  // Evict stale entries on startup
+  evict();
+  flush();
+
+  return {
+    get(channelId, threadTs) {
+      const entry = sessions[`${channelId}:${threadTs}`];
+      if (!entry) return undefined;
+      // Check TTL on read
+      if (Date.now() - entry.ts > SESSION_TTL_MS) {
+        delete sessions[`${channelId}:${threadTs}`];
+        return undefined;
+      }
+      return entry.sessionId;
+    },
+    set(channelId, threadTs, sessionId) {
+      sessions[`${channelId}:${threadTs}`] = { sessionId, ts: Date.now() };
+      evict();
+      flush();
+    },
+  };
+}

package/src/think.ts

@@ -0,0 +1,188 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import type { LituanicConfig } from "./config.js";
+import type { IncomingEvent } from "./gateway.js";
+import type { MemoryManager } from "./memory.js";
+import type { SessionStore } from "./sessions.js";
+import { createSlackMcpServer } from "./tools.js";
+import type { App } from "@slack/bolt";
+
+export interface ThinkOptions {
+  config: LituanicConfig;
+  event: IncomingEvent;
+  memory: MemoryManager;
+  sessions: SessionStore;
+  slack?: App;
+  onNotification?: (message: string) => void;
+  onProgress?: (text: string) => void;
+}
+
+export interface ThinkResult {
+  response: string;
+  model: string;
+  sessionId?: string;
+  costUsd?: number;
+  turns?: number;
+  stopReason?: string;
+}
+
+export async function think(options: ThinkOptions): Promise<ThinkResult> {
+  const { config, event, memory, sessions, slack, onNotification, onProgress } = options;
+
+  // Session continuity: Slack thread = SDK session
+  const existingSession =
+    event.channelId && event.threadTs
+      ? sessions.get(event.channelId, event.threadTs)
+      : undefined;
+
+  // Channel memory appended to system prompt
+  let append = "";
+  if (event.channelId) {
+    const channelMemory = memory.readChannel(event.channelId);
+    if (channelMemory) append = `\n\n## Channel Context\n\n${channelMemory}`;
+  }
+
+  // Effort: high for interactive, low for cron
+  const effort = event.source === "cron" ? "low" as const : "high" as const;
+
+  const mcpServers: Record<string, any> = {};
+  if (slack) mcpServers.slack = createSlackMcpServer(slack, event);
+
+  let result = "";
+  let sessionId: string | undefined;
+  let costUsd: number | undefined;
+  let turns: number | undefined;
+  let stopReason: string | undefined;
+
+  for await (const message of query({
+    prompt: event.text,
+    options: {
+      // Session: resume existing thread or start fresh
+      ...(existingSession ? { resume: existingSession } : {}),
+
+      // Model
+      model: config.model,
+      fallbackModel: config.fallbackModel,
+      effort,
+
+      // Working directory
+      cwd: config.cwd,
+
+      // System prompt: Claude Code's battle-tested preset + our channel memory
+      systemPrompt: {
+        type: "preset",
+        preset: "claude_code",
+        append,
+      },
+
+      // SDK loads CLAUDE.md + .claude/skills/ automatically
+      settingSources: ["project"],
+
+      // All built-in tools + subagents + skills
+      allowedTools: [
+        "Read", "Write", "Edit", "Bash", "Glob", "Grep",
+        "WebFetch", "WebSearch", "Agent", "Skill",
+      ],
+
+      // Autonomous operation
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+
+      // Safety caps
+      maxTurns: config.maxTurns,
+      maxBudgetUsd: config.maxBudgetUsd,
+
+      // Sandbox: SDK-native command isolation
+      sandbox: config.sandbox
+        ? { enabled: true, autoAllowBashIfSandboxed: true }
+        : undefined,
+
+      // Security: canUseTool for blocked patterns
+      canUseTool: async (tool, input) => {
+        if (tool === "Bash") {
+          const command = String((input as any).command ?? "");
+          for (const pattern of config.blockedPatterns) {
+            if (pattern.test(command)) {
+              return { behavior: "deny" as const, message: `Blocked: ${pattern}` };
+            }
+          }
+        }
+        return { behavior: "allow" as const, updatedInput: input };
+      },
+
+      // Environment: pass through all env vars (secrets from op run)
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((e): e is [string, string] => e[1] !== undefined),
+      ),
+
+      // File checkpointing: free rewind on error
+      enableFileCheckpointing: true,
+
+      // MCP servers (Slack tools)
+      mcpServers,
+
+      // Notifications + progress hooks
+      hooks: {
+        ...(onNotification
+          ? {
+              Notification: [{
+                hooks: [async (input: any) => {
+                  onNotification(input?.message ?? "");
+                  return {};
+                }],
+              }],
+            }
+          : {}),
+      },
+    },
+  })) {
+    // Capture session ID
+    if (message.type === "system" && message.subtype === "init") {
+      sessionId = message.session_id;
+    }
+
+    // Stream progress: forward assistant text to caller
+    if (message.type === "assistant" && onProgress) {
+      const content = (message as any).message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            onProgress(block.text.slice(0, 100));
+          }
+        }
+      }
+    }
+
+    // Final result
+    if (message.type === "result") {
+      const msg = message as any;
+      sessionId = msg.session_id ?? sessionId;
+      costUsd = msg.total_cost_usd;
+      turns = msg.num_turns;
+      stopReason = msg.subtype;
+
+      if (msg.subtype === "success") {
+        result = msg.result ?? "";
+      } else if (msg.subtype === "error_max_turns") {
+        result = `Hit turn limit (${config.maxTurns}). Session saved — follow up in this thread to continue.`;
+      } else if (msg.subtype === "error_max_budget_usd") {
+        result = `Hit budget limit ($${config.maxBudgetUsd}). Session saved — follow up to continue.`;
+      } else {
+        result = `Agent stopped: ${msg.subtype}`;
+      }
+    }
+  }
+
+  // Store session for thread continuity
+  if (sessionId && event.channelId && event.threadTs) {
+    sessions.set(event.channelId, event.threadTs, sessionId);
+  }
+
+  // Daily log with cost
+  const summary = result.slice(0, 80).replace(/\n/g, " ");
+  const costStr = costUsd !== undefined ? ` ($${costUsd.toFixed(4)})` : "";
+  memory.appendDailyLog(
+    `[${event.source}] ${event.channelId ?? "?"}: ${summary}${result.length > 80 ? "..." : ""}${costStr}`,
+  );
+
+  return { response: result, model: config.model, sessionId, costUsd, turns, stopReason };
+}