@suwujs/king-ai 0.2.0

package/dist/src/host-timeline.d.ts

@@ -0,0 +1,24 @@
+export type HostTimelineEventType = "host.command";
+export interface HostTimelineEvent {
+    at: string;
+    type: HostTimelineEventType;
+    command: string;
+    ok: boolean;
+    exitCode: number;
+    destructive: boolean;
+    durationMs: number;
+    actorRole?: string;
+    textPreview?: string;
+    jsonSummary?: unknown;
+    error?: string;
+}
+export interface HostTimelineReadOptions {
+    path?: string;
+    limit?: number;
+}
+export declare function hostTimelinePath(path?: string): string;
+export declare function appendHostTimelineEvent(event: HostTimelineEvent, path?: string): Promise<void>;
+export declare function readHostTimeline(options?: HostTimelineReadOptions): Promise<HostTimelineEvent[]>;
+export declare function formatHostTimeline(events: HostTimelineEvent[]): string;
+export declare function summarizeHostCommandJson(command: string, json: unknown): unknown;
+export declare function previewText(value: string, maxLength?: number): string | undefined;

package/dist/src/host-timeline.js

@@ -0,0 +1,161 @@
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { HOST_EVENTS_PATH } from "./paths.js";
+export function hostTimelinePath(path = HOST_EVENTS_PATH) {
+    return path;
+}
+export async function appendHostTimelineEvent(event, path = HOST_EVENTS_PATH) {
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, `${JSON.stringify(event)}\n`, "utf8");
+}
+export async function readHostTimeline(options = {}) {
+    const path = options.path ?? HOST_EVENTS_PATH;
+    const limit = normalizeLimit(options.limit);
+    let content = "";
+    try {
+        content = await readFile(path, "utf8");
+    }
+    catch (err) {
+        if (err && typeof err === "object" && err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const events = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .flatMap((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return isHostTimelineEvent(parsed) ? [parsed] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    return limit ? events.slice(-limit) : events;
+}
+export function formatHostTimeline(events) {
+    if (events.length === 0)
+        return "no host command events";
+    return events.map((event) => {
+        const status = event.ok ? "ok" : "failed";
+        const role = event.actorRole ? ` role=${event.actorRole}` : "";
+        const destructive = event.destructive ? " destructive" : "";
+        const error = event.error ? ` error=${event.error}` : "";
+        return `${event.at} ${event.command} ${status} exit=${event.exitCode}${role}${destructive} ${event.durationMs}ms${error}`;
+    }).join("\n");
+}
+export function summarizeHostCommandJson(command, json) {
+    if (!json || typeof json !== "object")
+        return undefined;
+    const value = json;
+    if (command === "status") {
+        return {
+            ok: value.ok,
+            computerId: value.computerId,
+            agents: Array.isArray(value.agents) ? value.agents.length : undefined,
+            events: Array.isArray(value.events) ? value.events.length : undefined
+        };
+    }
+    if (command === "usage") {
+        return {
+            agents: value.agents,
+            totalTokens: value.totalTokens,
+            budget: value.budget
+        };
+    }
+    if (command === "events") {
+        return { events: Array.isArray(value.events) ? value.events.length : undefined };
+    }
+    if (command === "timeline") {
+        return { events: Array.isArray(value.events) ? value.events.length : undefined };
+    }
+    if (command === "doctor") {
+        return {
+            exitCode: value.exitCode,
+            results: Array.isArray(value.results) ? value.results.length : undefined
+        };
+    }
+    if (command === "plan-run" || command === "preflight") {
+        return {
+            ready: value.ready,
+            mode: value.options?.mode,
+            engine: value.options?.engine,
+            errors: Array.isArray(value.errors) ? value.errors.length : undefined,
+            warnings: Array.isArray(value.warnings) ? value.warnings.length : undefined
+        };
+    }
+    if (command === "submit-run") {
+        const request = value.request;
+        return {
+            requestId: request?.id,
+            status: request?.status,
+            ready: request?.ready,
+            effectiveEngine: request?.effectiveEngine
+        };
+    }
+    if (command === "run-requests") {
+        return { requests: Array.isArray(value.requests) ? value.requests.length : undefined };
+    }
+    if (command === "run-request" || command === "update-run") {
+        const request = value.request;
+        return {
+            requestId: request?.id,
+            status: request?.status,
+            ready: request?.ready,
+            effectiveEngine: request?.effectiveEngine
+        };
+    }
+    if (command === "execute-run") {
+        const request = value.request;
+        return {
+            requestId: request?.id,
+            status: request?.status,
+            resultCommand: request?.result?.command,
+            resultOk: request?.result?.ok,
+            resultExitCode: request?.result?.exitCode
+        };
+    }
+    if (command === "plan-export") {
+        return {
+            runId: value.runId,
+            exportDir: value.exportDir,
+            workspaceFileCount: value.workspaceFileCount,
+            repoPatchFiles: Array.isArray(value.repoPatchFiles) ? value.repoPatchFiles.length : undefined
+        };
+    }
+    if (command === "export") {
+        return {
+            runId: value.runId,
+            exportDir: value.exportDir,
+            writtenFiles: Array.isArray(value.writtenFiles) ? value.writtenFiles.length : undefined
+        };
+    }
+    return undefined;
+}
+export function previewText(value, maxLength = 240) {
+    const text = value.replace(/\s+/g, " ").trim();
+    if (!text)
+        return undefined;
+    return text.length > maxLength ? `${text.slice(0, maxLength - 3)}...` : text;
+}
+function normalizeLimit(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || value < 1)
+        return undefined;
+    return Math.floor(value);
+}
+function isHostTimelineEvent(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const event = value;
+    return event.type === "host.command" &&
+        typeof event.at === "string" &&
+        typeof event.command === "string" &&
+        typeof event.ok === "boolean" &&
+        typeof event.exitCode === "number" &&
+        typeof event.destructive === "boolean" &&
+        typeof event.durationMs === "number";
+}

package/dist/src/jsonl.d.ts

@@ -0,0 +1,13 @@
+export declare function appendJsonl(path: string, value: unknown): Promise<void>;
+export declare function readJsonl(path: string): Promise<unknown[]>;
+export interface CompactJsonlResult {
+    path: string;
+    records: number;
+    written: number;
+}
+/**
+ * Rewrite an append-only JSONL file into the reduced snapshot returned by `reduce` (typically the
+ * merged latest state). The rewrite is atomic (temp file + rename) and holds the same write lock
+ * as appendJsonl, so a compaction never races a concurrent append.
+ */
+export declare function compactJsonl(path: string, reduce: (records: unknown[]) => unknown[]): Promise<CompactJsonlResult>;

package/dist/src/jsonl.js

@@ -0,0 +1,47 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+/**
+ * Per-path write chain. Appends and compactions to the same append-only JSONL file are
+ * serialized through this map so concurrent role activity (multiple agents writing the same
+ * ledger) cannot interleave partial lines or race a compaction rewrite.
+ */
+const writeChains = new Map();
+function withPathLock(path, fn) {
+    const prev = writeChains.get(path) ?? Promise.resolve();
+    // Run after the previous mutation settles, whether it resolved or rejected, so one failed
+    // write never deadlocks the queue.
+    const run = prev.then(fn, fn);
+    writeChains.set(path, run.then(() => undefined, () => undefined));
+    return run;
+}
+export async function appendJsonl(path, value) {
+    await withPathLock(path, async () => {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, `${JSON.stringify(value)}\n`, { encoding: "utf8", flag: "a" });
+    });
+}
+export async function readJsonl(path) {
+    const text = await readFile(path, "utf8").catch((err) => {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT")
+            return "";
+        throw err;
+    });
+    return text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+/**
+ * Rewrite an append-only JSONL file into the reduced snapshot returned by `reduce` (typically the
+ * merged latest state). The rewrite is atomic (temp file + rename) and holds the same write lock
+ * as appendJsonl, so a compaction never races a concurrent append.
+ */
+export async function compactJsonl(path, reduce) {
+    return withPathLock(path, async () => {
+        const records = await readJsonl(path);
+        const compacted = reduce(records);
+        await mkdir(dirname(path), { recursive: true });
+        const tmp = `${path}.compact-${process.pid}-${Date.now()}.tmp`;
+        const body = compacted.map((record) => JSON.stringify(record)).join("\n");
+        await writeFile(tmp, body.length ? `${body}\n` : "", "utf8");
+        await rename(tmp, path);
+        return { path, records: records.length, written: compacted.length };
+    });
+}

package/dist/src/lifecycle.d.ts

@@ -0,0 +1,5 @@
+import type { AgentLifecycle } from "./types.js";
+export declare const DEFAULT_AGENT_LIFECYCLE: AgentLifecycle;
+export declare function normalizeAgentLifecycle(value: unknown): AgentLifecycle;
+export declare function shouldHostAgent(lifecycle: AgentLifecycle): boolean;
+export declare function runtimeLifecycleNote(lifecycle: AgentLifecycle): string;

package/dist/src/lifecycle.js

@@ -0,0 +1,18 @@
+export const DEFAULT_AGENT_LIFECYCLE = "on-demand";
+export function normalizeAgentLifecycle(value) {
+    return value === "24/7" || value === "idle_cached" || value === "disabled" || value === "on-demand"
+        ? value
+        : DEFAULT_AGENT_LIFECYCLE;
+}
+export function shouldHostAgent(lifecycle) {
+    return lifecycle !== "disabled";
+}
+export function runtimeLifecycleNote(lifecycle) {
+    if (lifecycle === "disabled")
+        return "disabled - not hosted by this daemon";
+    if (lifecycle === "idle_cached")
+        return "idle_cached - event-triggered; session reuse is best-effort through the selected engine";
+    if (lifecycle === "24/7")
+        return "24/7 - hosted continuously, but turns remain runtime-event driven in this daemon";
+    return "on-demand - hosted and woken by runtime activity";
+}

package/dist/src/message-routing.d.ts

@@ -0,0 +1,32 @@
+export type RuntimeMessagePriority = "normal" | "steer" | "urgent";
+export type RuntimeMessageType = "message" | "decision" | "blocker" | "approval" | "system";
+export type RuntimeRouteHint = "ignore" | "monitor" | "respond" | "steer";
+export interface RuntimeMessageLike {
+    id?: string;
+    conversation_id?: string;
+    conversation_title?: string;
+    conversation_kind?: string;
+    conversation_topic?: string;
+    author_name?: string;
+    author_kind?: string;
+    kind?: string;
+    body?: string;
+    priority?: string;
+    message_type?: string;
+    to_agent_id?: string;
+    created_at?: number;
+}
+export interface RoutedRuntimeMessage<T extends RuntimeMessageLike = RuntimeMessageLike> {
+    row: T;
+    score: number;
+    priority: RuntimeMessagePriority;
+    type: RuntimeMessageType;
+    route: RuntimeRouteHint;
+    reasons: string[];
+}
+export declare function normalizeMessageType(row: RuntimeMessageLike): RuntimeMessageType;
+export declare function normalizeMessagePriority(row: RuntimeMessageLike): RuntimeMessagePriority;
+export declare function routeRuntimeMessage(row: RuntimeMessageLike, agentId: string): RoutedRuntimeMessage;
+export declare function sortRuntimeMessages<T extends RuntimeMessageLike>(rows: T[], agentId: string): RoutedRuntimeMessage<T>[];
+export declare function messageRouteTag(routed: Pick<RoutedRuntimeMessage, "priority" | "type" | "route">): string;
+export declare function formatMessageRouteSummary<T extends RuntimeMessageLike>(rows: T[], agentId: string, max?: number): string;

package/dist/src/message-routing.js

@@ -0,0 +1,119 @@
+function lower(value) {
+    return (value ?? "").toLowerCase();
+}
+function isMentioned(row, agentId) {
+    const body = row.body ?? "";
+    return body.includes(`@${agentId}`);
+}
+export function normalizeMessageType(row) {
+    const explicit = lower(row.message_type);
+    if (explicit === "decision" || explicit === "blocker" || explicit === "approval" || explicit === "message")
+        return explicit;
+    if (explicit === "system")
+        return "system";
+    if (row.kind === "system" || row.author_kind === "system")
+        return "system";
+    const body = lower(row.body);
+    if (/\bapproval required\b|\bapproval requested\b|\bapprove\b|\bdeny\b/.test(body))
+        return "approval";
+    if (/\bblocked\b|\bblocker\b|\bstuck\b|\bwaiting on\b/.test(body))
+        return "blocker";
+    if (/\bdecision\b|\bdecide\b|\bapproved\b|\brejected\b/.test(body))
+        return "decision";
+    return "message";
+}
+export function normalizeMessagePriority(row) {
+    const explicit = lower(row.priority);
+    if (explicit === "urgent" || explicit === "steer")
+        return explicit;
+    const type = normalizeMessageType(row);
+    if (type === "approval" || type === "blocker")
+        return "urgent";
+    if (type === "decision")
+        return "steer";
+    return "normal";
+}
+export function routeRuntimeMessage(row, agentId) {
+    const type = normalizeMessageType(row);
+    const priority = normalizeMessagePriority(row);
+    const reasons = [];
+    let score = 0;
+    if (row.to_agent_id === agentId) {
+        score += 70;
+        reasons.push("targeted");
+    }
+    else if (row.to_agent_id) {
+        score -= 100;
+        reasons.push("targeted elsewhere");
+    }
+    if (row.conversation_kind === "direct") {
+        score += 45;
+        reasons.push("direct");
+    }
+    if (row.author_kind === "human") {
+        score += 30;
+        reasons.push("human");
+    }
+    if (isMentioned(row, agentId)) {
+        score += 35;
+        reasons.push("mention");
+    }
+    if (priority === "urgent") {
+        score += 60;
+        reasons.push("urgent");
+    }
+    else if (priority === "steer") {
+        score += 45;
+        reasons.push("steer");
+    }
+    if (type === "approval") {
+        score += 55;
+        reasons.push("approval");
+    }
+    else if (type === "blocker") {
+        score += 45;
+        reasons.push("blocker");
+    }
+    else if (type === "decision") {
+        score += 30;
+        reasons.push("decision");
+    }
+    else if (type === "system") {
+        score -= 15;
+        reasons.push("system");
+    }
+    const route = score < 0
+        ? "ignore"
+        : priority === "urgent" || priority === "steer" || row.conversation_kind === "direct" || isMentioned(row, agentId)
+            ? "steer"
+            : row.author_kind === "human"
+                ? "respond"
+                : "monitor";
+    return { row, score, priority, type, route, reasons };
+}
+export function sortRuntimeMessages(rows, agentId) {
+    return rows
+        .map((row) => routeRuntimeMessage(row, agentId))
+        .sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return (a.row.created_at ?? 0) - (b.row.created_at ?? 0);
+    });
+}
+export function messageRouteTag(routed) {
+    const type = routed.type === "message" ? "msg" : routed.type;
+    return `${routed.route}/${routed.priority}/${type}`;
+}
+export function formatMessageRouteSummary(rows, agentId, max = 8) {
+    const routed = sortRuntimeMessages(rows, agentId).slice(0, max);
+    if (routed.length === 0)
+        return "";
+    return routed
+        .map((item) => {
+        const id = item.row.id ?? "?";
+        const who = item.row.author_name ?? "someone";
+        const body = item.row.kind === "system" ? "[system]" : (item.row.body ?? "").replace(/\s+/g, " ").slice(0, 120);
+        return `[${messageRouteTag(item)} score=${item.score}] ${id} ${who}: ${body}`;
+    })
+        .join("\n");
+}

package/dist/src/paths.d.ts

@@ -0,0 +1,19 @@
+export declare const APP_NAME = "king-ai";
+export type CommandName = "king-ai";
+export declare function normalizeCommandName(raw?: string): CommandName;
+export declare function commandNameFromProcess(argv0?: string): CommandName;
+export declare function resolveConfigDir(_commandName?: "king-ai"): string;
+export declare const CONFIG_DIR: string;
+export declare const LEGACY_CONFIG_DIR: string;
+export declare const CONFIG_PATH: string;
+export declare const LEGACY_CONFIG_PATH: string;
+export declare const AGENTS_ROOT: string;
+export declare const SESSIONS_DIR: string;
+export declare const TRIAGE_DIR: string;
+export declare const RUNNING_STATE_PATH: string;
+export declare const HEARTBEAT_PATH: string;
+export declare const HOST_EVENTS_PATH: string;
+export declare const HOST_RUNS_PATH: string;
+export declare const SERVICE_LABEL = "dev.king-ai";
+export declare const CURRENT_VERSION = "0.1.0";
+export declare const DEFAULT_SERVER: string;

package/dist/src/paths.js

@@ -0,0 +1,26 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const APP_NAME = "king-ai";
+export function normalizeCommandName(raw) {
+    return "king-ai";
+}
+export function commandNameFromProcess(argv0 = process.argv[1]) {
+    return normalizeCommandName(argv0);
+}
+export function resolveConfigDir(_commandName = commandNameFromProcess()) {
+    return process.env.KING_AI_CONFIG_DIR || join(homedir(), ".king-ai");
+}
+export const CONFIG_DIR = resolveConfigDir();
+export const LEGACY_CONFIG_DIR = join(homedir(), ".king");
+export const CONFIG_PATH = join(CONFIG_DIR, "computer.json");
+export const LEGACY_CONFIG_PATH = join(LEGACY_CONFIG_DIR, "computer.json");
+export const AGENTS_ROOT = join(CONFIG_DIR, "agents");
+export const SESSIONS_DIR = join(CONFIG_DIR, "sessions");
+export const TRIAGE_DIR = join(CONFIG_DIR, "triage");
+export const RUNNING_STATE_PATH = join(CONFIG_DIR, "running.json");
+export const HEARTBEAT_PATH = join(CONFIG_DIR, "heartbeat.json");
+export const HOST_EVENTS_PATH = join(CONFIG_DIR, "host-events.ndjson");
+export const HOST_RUNS_PATH = join(CONFIG_DIR, "host-runs.ndjson");
+export const SERVICE_LABEL = "dev.king-ai";
+export const CURRENT_VERSION = "0.1.0";
+export const DEFAULT_SERVER = process.env.KING_AI_SERVER_URL || "https://api.king-ai.ai";

package/dist/src/project-profile.d.ts

@@ -0,0 +1,49 @@
+export type ProjectDocumentKind = "readme" | "roadmap" | "docs" | "manifest" | "notes";
+export interface ProjectDocument {
+    path: string;
+    kind: ProjectDocumentKind;
+    title: string;
+    excerpt: string;
+    headings: string[];
+    score: number;
+}
+export interface ProjectProfile {
+    path: string;
+    languages: string[];
+    packageManagers: string[];
+    frameworks: string[];
+    ci: string[];
+    testFrameworks: string[];
+    hasReadme: boolean;
+    hasAgentsMd: boolean;
+    hasDocs: boolean;
+    issueTracker: "github" | "none";
+    githubRemote?: string;
+    readmeExcerpt?: string;
+    codeRoots: string[];
+    packageScripts: string[];
+}
+export interface ProjectIntent {
+    projectName: string;
+    summary: string;
+    canonicalDocs: ProjectDocument[];
+    roadmapDocs: ProjectDocument[];
+    codeRoots: string[];
+    packageScripts: string[];
+    strategicThemes: string[];
+    mission: string;
+}
+export declare function detectLanguages(projectPath: string): string[];
+export declare function detectPackageManagers(projectPath: string): string[];
+export declare function detectFrameworks(projectPath: string): string[];
+export declare function detectCI(projectPath: string): string[];
+export declare function detectTests(projectPath: string): string[];
+export declare function detectGitHubRemote(projectPath: string): string | undefined;
+export declare function scanReadme(projectPath: string): string | undefined;
+export declare function detectCodeRoots(projectPath: string): string[];
+export declare function detectPackageScripts(projectPath: string): string[];
+export declare function collectProjectDocs(projectPath: string): ProjectDocument[];
+export declare function scanProject(projectPath: string): ProjectProfile;
+export declare function buildProjectIntent(profile: ProjectProfile): ProjectIntent;
+export declare function formatProjectProfile(profile: ProjectProfile, intent?: ProjectIntent): string;
+export declare function runProjectProfile(projectPath: string): void;