indusagi-coding-agent 0.2.8 → 0.2.9

package/src/console/slash/resolve.ts

@@ -0,0 +1,63 @@
+/**
+ * Slash line resolution — parse a typed line, then match it against the registry.
+ */
+import type { SlashCommand, SlashRegistry } from "../contract.js";
+
+/**
+ * The leading character that marks a line as a slash invocation.
+ */
+export const SLASH_PREFIX = "/" as const;
+
+const COMMAND_TOKEN = /^[a-zA-Z][a-zA-Z0-9:-]*(?:\s|$)/;
+
+/**
+ * The lexical split of a slash line into its command token and argument tail.
+ */
+export interface SlashLine {
+  readonly name: string;
+  readonly args: string;
+}
+
+/**
+ * Whether a typed line is shaped like a slash command at all.
+ */
+export function looksLikeSlash(input: string): boolean {
+  const trimmed = input.trimStart();
+  if (!trimmed.startsWith(SLASH_PREFIX)) return false;
+  return COMMAND_TOKEN.test(trimmed.slice(SLASH_PREFIX.length));
+}
+
+/**
+ * Split a slash line into its {@link SlashLine} token/argument pair.
+ */
+export function parseSlash(input: string): SlashLine | undefined {
+  if (!looksLikeSlash(input)) return void 0;
+  const body = input.trimStart().slice(SLASH_PREFIX.length);
+  const gap = body.search(/\s/);
+  if (gap === -1) {
+    return { name: body.toLowerCase(), args: "" };
+  }
+  return {
+    name: body.slice(0, gap).toLowerCase(),
+    args: body.slice(gap + 1).trim()
+  };
+}
+
+/**
+ * The outcome of resolving a typed line against a {@link SlashRegistry}.
+ */
+export type SlashResolution =
+  | { readonly kind: "not-slash" }
+  | { readonly kind: "match"; readonly command: SlashCommand; readonly args: string }
+  | { readonly kind: "miss"; readonly name: string };
+
+/**
+ * Resolve a raw composer line against the registry to a {@link SlashResolution}.
+ */
+export function resolveSlash(input: string, registry: SlashRegistry): SlashResolution {
+  const line = parseSlash(input);
+  if (line === void 0) return { kind: "not-slash" };
+  const command = registry.index.get(line.name);
+  if (command === void 0) return { kind: "miss", name: line.name };
+  return { kind: "match", command, args: line.args };
+}

package/src/console/startup.ts

@@ -0,0 +1,209 @@
+/**
+ * Startup gathering — the pure resource/notices/changelog reader the banner draws.
+ *
+ * The interactive console opens with a one-shot survey of what the session has to
+ * work with: which context documents the agent will read, which capability cards
+ * (skills) and prompt templates (commands) were discovered on disk, and a count
+ * of each. This module *gathers* that survey and nothing else.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { gatherSkillCards, loadMacros } from "../briefing/index.js";
+
+const PROFILE_DIR = ".indusagi";
+const CONTEXT_FILES = ["AGENTS.md", "CLAUDE.md"];
+
+function skillRoots(cwd: string, home: string) {
+  return [
+    { dir: join(cwd, PROFILE_DIR, "skills"), origin: "project" as const },
+    { dir: join(home, PROFILE_DIR, "skills"), origin: "user" as const }
+  ];
+}
+
+function macroRoots(cwd: string, home: string) {
+  return [
+    { dir: join(cwd, PROFILE_DIR, "commands"), origin: "project" as const, label: "project" },
+    { dir: join(home, PROFILE_DIR, "commands"), origin: "user" as const, label: "user" }
+  ];
+}
+
+function shortenPath(path: string, cwd: string, home: string) {
+  if (cwd.length > 0 && path.startsWith(cwd)) {
+    const rest = path.slice(cwd.length).replace(/^[/\\]+/, "");
+    return rest.length > 0 ? `./${rest}` : ".";
+  }
+  if (home.length > 0 && path.startsWith(home)) {
+    return `~${path.slice(home.length)}`;
+  }
+  return path;
+}
+
+const MAX_SECTION_LINES = 6;
+
+function capLines(lines: string[]) {
+  if (lines.length <= MAX_SECTION_LINES) return [...lines];
+  const head = lines.slice(0, MAX_SECTION_LINES);
+  return [...head, `... ${lines.length - MAX_SECTION_LINES} more`];
+}
+
+function section(title: string, lines: string[]): StartupSection | null {
+  const filtered = lines.map((line) => line.trim()).filter((line) => line.length > 0);
+  if (filtered.length === 0) return null;
+  return { title, lines: capLines(filtered), count: filtered.length };
+}
+
+function gatherContext(cwd: string, home: string) {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const root of [cwd, home]) {
+    if (root.length === 0) continue;
+    for (const name of CONTEXT_FILES) {
+      const path = join(root, name);
+      if (seen.has(path)) continue;
+      seen.add(path);
+      if (existsSync(path)) out.push(shortenPath(path, cwd, home));
+    }
+  }
+  return out;
+}
+
+function gatherSkills(cwd: string, home: string) {
+  let cards: Array<{ name: string; location: string }> = [];
+  try {
+    cards = gatherSkillCards(skillRoots(cwd, home)).cards.slice();
+  } catch {
+    cards = [];
+  }
+  return cards.map((card) => `${card.name}  ${shortenPath(card.location, cwd, home)}`);
+}
+
+function gatherPrompts(cwd: string, home: string) {
+  const lines: string[] = [];
+  const claimed = new Set<string>();
+  for (const root of macroRoots(cwd, home)) {
+    let loaded: Array<{ name: string; source: string }> = [];
+    try {
+      loaded = loadMacros(root.dir, { origin: root.origin, label: root.label });
+    } catch {
+      loaded = [];
+    }
+    for (const macro of loaded) {
+      if (claimed.has(macro.name)) continue;
+      claimed.add(macro.name);
+      lines.push(`/${macro.name}  ${shortenPath(macro.source, cwd, home)}`);
+    }
+  }
+  return lines;
+}
+
+/**
+ * Gather the startup map: context documents, skills, and prompt templates.
+ */
+export function gatherStartup(inputs: StartupInputs): StartupMap {
+  const { cwd, home } = inputs;
+  const sections: StartupSection[] = [];
+  const context = section("Context", gatherContext(cwd, home));
+  if (context) sections.push(context);
+  const skills = section("Skills", gatherSkills(cwd, home));
+  if (skills) sections.push(skills);
+  const prompts = section("Prompts", gatherPrompts(cwd, home));
+  if (prompts) sections.push(prompts);
+  return { sections };
+}
+
+function condenseChangelog(markdown: string, lastSeen?: string) {
+  if (lastSeen === void 0 || lastSeen.length === 0) return markdown.trim();
+  const lines = markdown.split("\n");
+  const kept: string[] = [];
+  for (const line of lines) {
+    const heading = /^##\s+\[?(\d+\.\d+\.\d+)\]?/.exec(line);
+    if (heading && heading[1] === lastSeen) break;
+    kept.push(line);
+  }
+  const joined = kept.join("\n").trim();
+  return joined.length > 0 ? joined : markdown.trim();
+}
+
+function reverseChangelogEntries(markdown: string) {
+  const isEntryHeading = (line: string) => /^##\s+\[?\d+\.\d+\.\d+\]?/.test(line);
+  const lines = markdown.split("\n");
+  const firstEntry = lines.findIndex(isEntryHeading);
+  if (firstEntry === -1) return markdown.trim();
+  const preamble = lines.slice(0, firstEntry).join("\n").trim();
+  const blocks: string[][] = [];
+  for (const line of lines.slice(firstEntry)) {
+    if (isEntryHeading(line)) blocks.push([line]);
+    else if (blocks.length > 0) blocks[blocks.length - 1].push(line);
+  }
+  blocks.reverse();
+  const body = blocks.map((block) => block.join("\n").trim()).filter((block) => block.length > 0).join("\n\n");
+  return preamble.length > 0 ? `${preamble}\n\n${body}` : body;
+}
+
+/**
+ * Gather the changelog survey for the banner.
+ */
+export function gatherChangelog(inputs: StartupInputs): StartupChangelog {
+  const { version, lastSeenVersion, changelogPath } = inputs;
+  const none: StartupChangelog = { mode: "none", version };
+  if (changelogPath === void 0 || !existsSync(changelogPath)) return none;
+  if (lastSeenVersion !== void 0 && lastSeenVersion === version) return none;
+  let raw: string;
+  try {
+    raw = readFileSync(changelogPath, "utf-8");
+  } catch {
+    return none;
+  }
+  const condensed = condenseChangelog(raw, lastSeenVersion);
+  if (condensed.length === 0) {
+    return { mode: "condensed", version };
+  }
+  if (lastSeenVersion === void 0) {
+    return { mode: "condensed", version };
+  }
+  return { mode: "full", version, markdown: reverseChangelogEntries(condensed) };
+}
+
+/**
+ * One labelled group inside the startup map.
+ */
+export interface StartupSection {
+  readonly title: string;
+  readonly lines: readonly string[];
+  readonly count: number;
+}
+
+/**
+ * The gathered survey the banner renders as the "Startup Map" panel.
+ */
+export interface StartupMap {
+  readonly sections: readonly StartupSection[];
+}
+
+/**
+ * The changelog survey the banner may render as a "What is new" block.
+ */
+export type StartupChangelogMode = "none" | "full" | "condensed";
+
+export interface StartupChangelog {
+  readonly mode: StartupChangelogMode;
+  readonly version: string;
+  readonly markdown?: string;
+}
+
+/** The per-line tone a startup notice carries. */
+export type StartupNoticeKind = "error" | "warning" | "info";
+
+export interface StartupNotice {
+  readonly kind: StartupNoticeKind;
+  readonly text: string;
+}
+
+/** What {@link gatherStartup} is handed to compute the survey. */
+export interface StartupInputs {
+  readonly cwd: string;
+  readonly home: string;
+  readonly version: string;
+  readonly lastSeenVersion?: string;
+  readonly changelogPath?: string;
+}

package/src/console/theme/adapter.ts

@@ -0,0 +1,45 @@
+/**
+ * Theme adapter binding — the single boundary where the console's semantic tokens become concrete terminal colours.
+ */
+import { createThemeAdapter } from "indusagi/react-ink";
+import type { InkThemeAdapter, ThemeTokens } from "../contract.js";
+
+/**
+ * Project the console's semantic tokens onto the framework's colour-key Record.
+ */
+export function frameworkColors(tokens: ThemeTokens): Record<string, string> {
+  return {
+    text: tokens.bodyText,
+    dim: tokens.mutedText,
+    muted: tokens.mutedText,
+    accent: tokens.signal,
+    borderMuted: tokens.quietFrame,
+    bashBorder: tokens.frame,
+    userMessage: "",
+    customMessage: tokens.cardAccent,
+    success: tokens.affirm,
+    warning: tokens.caution,
+    error: tokens.alarm,
+    info: tokens.notice,
+    highlight: tokens.inkText,
+    codeInline: tokens.codeInline,
+    heading: tokens.heading,
+    blockquoteBar: tokens.blockquoteBar,
+    diffAddedBg: tokens.diffAddedBg,
+    diffRemovedBg: tokens.diffRemovedBg,
+    diffAddedText: tokens.diffAddedText,
+    diffRemovedText: tokens.diffRemovedText,
+    synKeyword: tokens.synKeyword,
+    synString: tokens.synString,
+    synNumber: tokens.synNumber,
+    synComment: tokens.synComment,
+    synType: tokens.synType
+  };
+}
+
+/**
+ * Build the framework {@link InkThemeAdapter} for a scheme from its tokens.
+ */
+export function themeAdapter(schemeName: string, tokens: ThemeTokens): InkThemeAdapter {
+  return createThemeAdapter(schemeName, frameworkColors(tokens));
+}

package/src/console/theme/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Console theme engine — public barrel.
+ */
+export { SAFFRON_PALETTE, MIDNIGHT_PALETTE, DAYLIGHT_PALETTE, MIDNIGHT_CB_PALETTE, DAYLIGHT_CB_PALETTE, PALETTES } from "./palette.js";
+export { deriveTokens } from "./tokens.js";
+export { themeAdapter, frameworkColors } from "./adapter.js";
+export { THEMES, THEME_SCHEMES, resolveTheme } from "./resolve.js";

package/src/console/theme/palette.ts

@@ -0,0 +1,68 @@
+/**
+ * Theme palettes — the console's own re-derived accent ramps.
+ */
+import type { ThemePalette, ThemeScheme } from "../contract.js";
+
+/** The dark-terminal ramp. */
+export const MIDNIGHT_PALETTE: ThemePalette = {
+  primary: "#3ad6b4",
+  secondary: "#f0a24b",
+  tertiary: "#7c9fe8",
+  ink: "#f4f6fb",
+  body: "#c3c8d4",
+  muted: "#7e8696",
+  affirm: "#46c98a",
+  caution: "#e8b341",
+  alarm: "#ef6a6a"
+};
+
+/** The light-terminal ramp. */
+export const DAYLIGHT_PALETTE: ThemePalette = {
+  primary: "#0f8f78",
+  secondary: "#c26a10",
+  tertiary: "#3a5ec0",
+  ink: "#1c2230",
+  body: "#3a4253",
+  muted: "#6b7382",
+  affirm: "#1d9d63",
+  caution: "#a9740a",
+  alarm: "#c4322f"
+};
+
+/** The "IndusCode Saffron" dark-terminal ramp — the brand scheme. */
+export const SAFFRON_PALETTE: ThemePalette = {
+  primary: "#f7a23f",
+  secondary: "#3fd9b8",
+  tertiary: "#b9a589",
+  ink: "#fbf2e6",
+  body: "#f3e9dc",
+  muted: "#8a7a66",
+  affirm: "#7fd8a8",
+  caution: "#e8c172",
+  alarm: "#e8736b"
+};
+
+/** The dark-terminal color-blind-safe ramp. */
+export const MIDNIGHT_CB_PALETTE: ThemePalette = {
+  ...MIDNIGHT_PALETTE,
+  affirm: "#4aa3ff",
+  caution: "#f2c75c",
+  alarm: "#c83232"
+};
+
+/** The light-terminal color-blind-safe ramp. */
+export const DAYLIGHT_CB_PALETTE: ThemePalette = {
+  ...DAYLIGHT_PALETTE,
+  affirm: "#1f6fd6",
+  caution: "#8a5e00",
+  alarm: "#b02622"
+};
+
+/** The raw ramp for each scheme, keyed by {@link ThemeScheme}. */
+export const PALETTES: Readonly<Record<ThemeScheme, ThemePalette>> = {
+  saffron: SAFFRON_PALETTE,
+  midnight: MIDNIGHT_PALETTE,
+  daylight: DAYLIGHT_PALETTE,
+  "midnight-cb": MIDNIGHT_CB_PALETTE,
+  "daylight-cb": DAYLIGHT_CB_PALETTE
+};

package/src/console/theme/resolve.ts

@@ -0,0 +1,39 @@
+/**
+ * Theme resolution — assemble the fully-resolved {@link ConsoleTheme} for each scheme.
+ */
+import { DEFAULT_SCHEME, isThemeScheme, type ConsoleTheme, type ThemeScheme } from "../contract.js";
+import { PALETTES } from "./palette.js";
+import { themeAdapter } from "./adapter.js";
+import { deriveTokens } from "./tokens.js";
+
+function assembleTheme(scheme: ThemeScheme, palette = PALETTES[scheme]): ConsoleTheme {
+  const tokens = deriveTokens(palette);
+  return {
+    scheme,
+    palette,
+    tokens,
+    adapter: themeAdapter(scheme, tokens)
+  };
+}
+
+/** The built-in themes, fully resolved and keyed by {@link ThemeScheme}. */
+export const THEMES: Readonly<Record<ThemeScheme, ConsoleTheme>> = {
+  saffron: assembleTheme("saffron"),
+  midnight: assembleTheme("midnight"),
+  daylight: assembleTheme("daylight"),
+  "midnight-cb": assembleTheme("midnight-cb"),
+  "daylight-cb": assembleTheme("daylight-cb")
+};
+
+/**
+ * Resolve a scheme name to its fully-built {@link ConsoleTheme}.
+ */
+export function resolveTheme(scheme?: string | null): ConsoleTheme {
+  if (typeof scheme === "string" && isThemeScheme(scheme)) {
+    return THEMES[scheme];
+  }
+  return THEMES[DEFAULT_SCHEME];
+}
+
+/** The schemes the console offers, in picker order. */
+export const THEME_SCHEMES: readonly ThemeScheme[] = Object.keys(THEMES) as ThemeScheme[];

package/src/console/theme/tokens.ts

@@ -0,0 +1,71 @@
+/**
+ * Token derivation — expand a raw {@link ThemePalette} into the semantic {@link ThemeTokens}.
+ */
+import type { ThemePalette, ThemeTokens } from "../contract.js";
+
+function parseHex(hex: string): [number, number, number] {
+  let h = hex.trim().replace(/^#/, "");
+  if (h.length === 3) {
+    h = h.split("").map((c) => c + c).join("");
+  }
+  const n = Number.parseInt(h.slice(0, 6).padEnd(6, "0"), 16);
+  return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+
+function toHex([r, g, b]: [number, number, number]) {
+  const clamp = (v: number) => Math.max(0, Math.min(255, Math.round(v)));
+  return "#" + [clamp(r), clamp(g), clamp(b)].map((v) => v.toString(16).padStart(2, "0")).join("");
+}
+
+function mixHex(a: string, b: string, t: number) {
+  const [ar, ag, ab] = parseHex(a);
+  const [br, bg, bb] = parseHex(b);
+  return toHex([ar + (br - ar) * t, ag + (bg - ag) * t, ab + (bb - ab) * t]);
+}
+
+function diffBackground(hue: string, anchor: string) {
+  return mixHex(hue, anchor, 0.78);
+}
+
+function luminance(hex: string) {
+  const [r, g, b] = parseHex(hex);
+  return (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+}
+
+function backgroundAnchor(palette: ThemePalette) {
+  return luminance(palette.ink) >= 0.5 ? "#000000" : "#ffffff";
+}
+
+/**
+ * Map a raw accent ramp onto the closed semantic token set.
+ */
+export function deriveTokens(palette: ThemePalette): ThemeTokens {
+  const anchor = backgroundAnchor(palette);
+  return {
+    signal: palette.primary,
+    frame: palette.tertiary,
+    quietFrame: palette.muted,
+    promptSurface: palette.secondary,
+    cardAccent: palette.secondary,
+    bodyText: palette.body,
+    mutedText: palette.muted,
+    inkText: palette.ink,
+    notice: palette.tertiary,
+    affirm: palette.affirm,
+    caution: palette.caution,
+    alarm: palette.alarm,
+    pending: palette.primary,
+    codeInline: palette.primary,
+    heading: palette.primary,
+    blockquoteBar: palette.muted,
+    diffAddedBg: diffBackground(palette.affirm, anchor),
+    diffRemovedBg: diffBackground(palette.alarm, anchor),
+    diffAddedText: palette.affirm,
+    diffRemovedText: palette.alarm,
+    synKeyword: palette.primary,
+    synString: palette.affirm,
+    synNumber: palette.caution,
+    synComment: palette.muted,
+    synType: palette.tertiary
+  };
+}

package/src/entry.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * Thin executable bootstrap for the indusagi coding agent.
+ *
+ * The real work lives in the `boot/` subsystem; this file just installs the
+ * cross-cutting runtime concerns (process title, MCP log noise filter, heap
+ * headroom) and hands control to {@link boot}.
+ */
+import { argv as processArgv, env as processEnv } from "node:process";
+// `process` is a Node.js global; do NOT import it from `node:process` (which
+// exports only `argv`, `env`, etc. but not the global `process` itself).
+// Use the global directly throughout this file.
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { BRAND, boot, ensureHeapHeadroom } from "./boot/index.js";
+
+const MCP_NOISE_MARKER = "[MCP]";
+
+function installMcpNoiseFilter(): void {
+  const self = installMcpNoiseFilter as { installed?: boolean };
+  if (self.installed) return;
+  self.installed = true;
+  if (processEnv[BRAND.envDebug]) return;
+  const carriesMcpNoise = (args: unknown[]): boolean =>
+    typeof args[0] === "string" && (args[0] as string).includes(MCP_NOISE_MARKER);
+  const wrap =
+    (original: (...args: unknown[]) => void) =>
+    (...args: unknown[]): void => {
+      if (carriesMcpNoise(args)) return;
+      (original as (...a: unknown[]) => void)(...args);
+    };
+  console.log = wrap(console.log.bind(console)) as typeof console.log;
+  console.error = wrap(console.error.bind(console)) as typeof console.error;
+}
+
+function isProgramEntry(): boolean {
+  const entryArg = processArgv[1];
+  if (!entryArg) return false;
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(entryArg);
+  } catch {
+    return false;
+  }
+}
+
+process.title = BRAND.binNames[0];
+installMcpNoiseFilter();
+if (isProgramEntry()) {
+  ensureHeapHeadroom();
+  void boot(processArgv.slice(2)).then((code) => {
+    process.exitCode = code;
+    process.stdout.write("", () => process.exit(code));
+    setTimeout(() => process.exit(code), 1e3).unref();
+  });
+}

package/src/guardrails.ts

@@ -0,0 +1,37 @@
+// @ts-nocheck — barrel re-export for guardrails subsystem.
+// Preserves the package's public surface: `indusagi-coding-agent/guardrails`.
+
+// Permission gate
+export {
+  READ_ONLY_TOOL_NAMES,
+  EDIT_TOOL_NAMES,
+  makeRule,
+  resolveRuleDecision,
+  createPermissionGate,
+} from "./conductor/permissions.js";
+
+// Catastrophic-command classifier
+export { evaluateCatastrophic, bashSubcommandSubjects } from "./conductor/bash-guard.js";
+
+// Briefing
+export { composeBriefing } from "./briefing/compose.js";
+export { gatherContextDocs } from "./briefing/context-docs.js";
+
+// Stores
+export {
+  READ_STATE_HANDLE_KEY,
+  ReadStateStore,
+  createReadStateStore,
+} from "./boot/runners/read-state.js";
+export {
+  CHECKPOINT_HANDLE_KEY,
+  CheckpointStore,
+  createCheckpointStore,
+} from "./boot/runners/checkpoint.js";
+
+// Deck provisioner
+export { provisionDeck } from "./capability-deck/provision.js";
+
+// Stable refusal string (preserved verbatim)
+export const READ_BEFORE_EDIT_MESSAGE =
+  "File has not been read yet. Read it first before writing to it.";

package/src/index.ts

@@ -0,0 +1,18 @@
+export * as boot from "./boot/index.js";
+export * as workspace from "./workspace/index.js";
+export * as briefing from "./briefing/index.js";
+export * as launch from "./launch/index.js";
+export * as conductor from "./conductor/index.js";
+export * as capabilityDeck from "./capability-deck/index.js";
+export * as workflowEngine from "./workflow-engine/index.js";
+export * as windowBudget from "./window-budget/index.js";
+export * as consoleUi from "./console/index.js";
+export * as settings from "./settings/index.js";
+export * as kit from "./kit/index.js";
+export * as transcriptExport from "./transcript-export/index.js";
+export * as sessions from "./sessions/index.js";
+export * as addons from "./addons/index.js";
+export * as channels from "./channels/index.js";
+export * as runtimeBridge from "./runtime-bridge/index.js";
+export * as insight from "./insight/index.js";
+export { VERSION } from "./workspace/index.js";