@suwujs/king-ai 0.2.0

package/dist/src/runtime-data.d.ts

@@ -0,0 +1,68 @@
+import type { RunningEvent, RunningState } from "./service.js";
+import type { UsagePricingRule, UsageSummary } from "./usage.js";
+export type RuntimeClassification = "productive" | "idle" | "blocked" | "backlog_stuck" | "error";
+export interface ProviderCapability {
+    provider: string;
+    engines: string[];
+    usage: "local_tokens" | "api_usage" | "unavailable";
+    pricing: "env_pricing" | "provider_api" | "unavailable";
+    notes: string[];
+}
+export interface RuntimeResultsRow {
+    agent: string;
+    engine: string;
+    runId: string;
+    source: string;
+    status: string;
+    durationMs: number;
+    tokens: number;
+    classification: RuntimeClassification;
+    reason: string;
+}
+export interface UsageRuntimeDataFile {
+    schemaVersion: 1;
+    dataSource: {
+        mode: "daemon-state";
+        generatedAt: string;
+        secretValuesIncluded: false;
+        warnings: string[];
+    };
+    usage: UsageSummary;
+    providerCapabilities: ProviderCapability[];
+    runtimeResults: RuntimeResultsRow[];
+    state: {
+        version?: string;
+        pid?: number;
+        startedAt?: string;
+        serverUrl?: string;
+        computerId?: string;
+        workspaces: string[];
+        agents: Array<{
+            id: string;
+            name: string;
+            engine: string;
+            lifecycle?: string;
+            status?: string;
+            model?: string;
+            workspaceRoot?: string;
+            updatedAt: string;
+        }>;
+        events: RunningEvent[];
+    };
+}
+export declare const PROVIDER_CAPABILITIES: ProviderCapability[];
+export declare const RUNTIME_RESULTS_HEADER: string;
+export declare function formatProviderCapabilities(capabilities?: ProviderCapability[]): string;
+export declare function classifyRuntimeEvent(event: RunningEvent): {
+    classification: RuntimeClassification;
+    reason: string;
+};
+export declare function buildRuntimeResultsRows(state: RunningState | null): RuntimeResultsRow[];
+export declare function formatRuntimeResultsTable(rows: RuntimeResultsRow[]): string;
+export declare function buildUsageRuntimeData(state: RunningState | null, options?: {
+    budget?: number | null;
+    pricingRules?: UsagePricingRule[];
+    generatedAt?: string;
+}): UsageRuntimeDataFile;
+export declare function writeUsageRuntimeData(file: string, data: UsageRuntimeDataFile): Promise<string>;
+export declare function sanitizeRuntimeData<T>(value: T, home?: string): T;

package/dist/src/runtime-data.js

@@ -0,0 +1,172 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+import { summarizeAgentUsage } from "./usage.js";
+export const PROVIDER_CAPABILITIES = [
+    {
+        provider: "OpenAI",
+        engines: ["codex"],
+        usage: "local_tokens",
+        pricing: "env_pricing",
+        notes: ["King AI records CLI-reported token usage when available.", "Set KING_AI_USAGE_PRICING for estimated local cost."]
+    },
+    {
+        provider: "Anthropic",
+        engines: ["claude"],
+        usage: "local_tokens",
+        pricing: "env_pricing",
+        notes: ["King AI records Claude CLI usage fields when the engine returns them.", "Set KING_AI_USAGE_PRICING for estimated local cost."]
+    },
+    {
+        provider: "OpenRouter",
+        engines: ["openrouter"],
+        usage: "unavailable",
+        pricing: "env_pricing",
+        notes: ["No first-class King AI engine adapter is wired yet.", "Pricing can still be represented with KING_AI_USAGE_PRICING once an adapter records usage."]
+    }
+];
+export const RUNTIME_RESULTS_HEADER = [
+    "agent",
+    "engine",
+    "run_id",
+    "source",
+    "status",
+    "duration_ms",
+    "tokens",
+    "classification",
+    "reason"
+].join("\t") + "\n";
+export function formatProviderCapabilities(capabilities = PROVIDER_CAPABILITIES) {
+    return [
+        "provider capabilities:",
+        ...capabilities.map((capability) => `  - ${capability.provider}: engines=${capability.engines.join(",") || "none"} usage=${capability.usage} pricing=${capability.pricing}`)
+    ].join("\n");
+}
+export function classifyRuntimeEvent(event) {
+    const kind = event.kind.toLowerCase();
+    const detail = event.detail ?? "";
+    if (/error|failed|failure/.test(kind) || /error|failed|usage limit|quota/i.test(detail)) {
+        return { classification: "error", reason: detail || event.kind };
+    }
+    if (/blocked|budget\.exceeded/.test(kind) || /blocked|waiting for dependency/i.test(detail)) {
+        return { classification: "blocked", reason: detail || event.kind };
+    }
+    if (/wake\.received|queue\.backlog|agenda/.test(kind) && /pending|unread|backlog/i.test(detail)) {
+        return { classification: "backlog_stuck", reason: detail || event.kind };
+    }
+    if (/turn\.completed|task\.transition|artifact\.created|engine\.session\.started/.test(kind)) {
+        return { classification: "productive", reason: detail || event.kind };
+    }
+    return { classification: "idle", reason: detail || event.kind };
+}
+export function buildRuntimeResultsRows(state) {
+    const events = state?.events ?? [];
+    const rows = [];
+    for (const agent of state?.agents ?? []) {
+        if (!agent.runStats || agent.runStats.turns === 0)
+            continue;
+        const latestEvent = [...events].reverse().find((event) => event.detail?.includes(agent.id)) ?? events.at(-1);
+        const classified = latestEvent ? classifyRuntimeEvent(latestEvent) : { classification: agent.runStats.failed > 0 ? "error" : "idle", reason: "run stats only" };
+        rows.push({
+            agent: agent.id,
+            engine: agent.engine,
+            runId: agent.runStats.lastRunAt ?? "",
+            source: "daemon-state",
+            status: agent.runStats.lastStatus ?? agent.status ?? "unknown",
+            durationMs: agent.runStats.lastDurationMs ?? 0,
+            tokens: agent.runStats.totalTokens,
+            classification: classified.classification,
+            reason: classified.reason
+        });
+    }
+    return rows.sort((left, right) => left.agent.localeCompare(right.agent));
+}
+export function formatRuntimeResultsTable(rows) {
+    return RUNTIME_RESULTS_HEADER + rows.map((row) => [
+        row.agent,
+        row.engine,
+        row.runId,
+        row.source,
+        row.status,
+        String(row.durationMs),
+        String(row.tokens),
+        row.classification,
+        row.reason
+    ].map(tsvCell).join("\t")).join("\n") + (rows.length ? "\n" : "");
+}
+export function buildUsageRuntimeData(state, options = {}) {
+    const usage = summarizeAgentUsage(state?.agents ?? [], options.budget, options.pricingRules ?? []);
+    const warnings = [];
+    if (!state)
+        warnings.push("No running daemon state was found.");
+    if (!usage.turns)
+        warnings.push("No completed agent run usage has been recorded yet.");
+    const workspaces = state?.capabilities?.workspaces ?? [];
+    return sanitizeRuntimeData({
+        schemaVersion: 1,
+        dataSource: {
+            mode: "daemon-state",
+            generatedAt: options.generatedAt ?? new Date().toISOString(),
+            secretValuesIncluded: false,
+            warnings
+        },
+        usage,
+        providerCapabilities: PROVIDER_CAPABILITIES,
+        runtimeResults: buildRuntimeResultsRows(state),
+        state: {
+            version: state?.version,
+            pid: state?.pid,
+            startedAt: state?.startedAt,
+            serverUrl: state?.serverUrl,
+            computerId: state?.computerId,
+            workspaces,
+            agents: (state?.agents ?? []).map((agent) => ({
+                id: agent.id,
+                name: agent.name,
+                engine: agent.engine,
+                lifecycle: agent.lifecycle,
+                status: agent.status,
+                model: agent.model,
+                workspaceRoot: agent.workspaceRoot,
+                updatedAt: agent.updatedAt
+            })),
+            events: state?.events ?? []
+        }
+    });
+}
+export async function writeUsageRuntimeData(file, data) {
+    const out = resolve(file);
+    await mkdir(dirname(out), { recursive: true });
+    await writeFile(out, JSON.stringify(data, null, 2), "utf8");
+    return out;
+}
+export function sanitizeRuntimeData(value, home = homedir()) {
+    return sanitizeValue(value, normalizePath(home));
+}
+function sanitizeValue(value, home) {
+    if (typeof value === "string")
+        return sanitizeString(value, home);
+    if (Array.isArray(value))
+        return value.map((entry) => sanitizeValue(entry, home));
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, sanitizeValue(entry, home)]));
+}
+function sanitizeString(value, home) {
+    const normalized = normalizePath(value);
+    if (home && normalized === home)
+        return "<home>";
+    if (home && normalized.startsWith(`${home}/`))
+        return `<home>/${normalized.slice(home.length + 1)}`;
+    const homeRedacted = home ? value.replace(new RegExp(escapeRegExp(home), "g"), "<home>") : value;
+    return homeRedacted.replace(/\/Users\/[^/\s"]+/g, "private://user");
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function tsvCell(value) {
+    return value.replace(/\t/g, " ").replace(/\r?\n/g, " ").trim();
+}

package/dist/src/service.d.ts

@@ -0,0 +1,114 @@
+import type { CommandName } from "./paths.js";
+import type { LocalCapabilities } from "./workspace.js";
+import type { WorktreePlan } from "./worktree.js";
+import type { AgentRunStats } from "./usage.js";
+import type { TokenBudgetCheck } from "./usage.js";
+import type { RemediationAdvice } from "./remediation.js";
+import type { AgentConfigWarning } from "./agent-config-validation.js";
+export type DarwinServiceStatus = {
+    pid: number | null;
+    lastExitStatus: number | null;
+};
+export type RunningEvent = {
+    at: string;
+    kind: string;
+    detail?: string;
+};
+export type RunningEventCategory = "agent" | "turn" | "budget" | "daemon" | "other";
+export type RunningAgentState = {
+    id: string;
+    name: string;
+    engine: string;
+    lifecycle?: string;
+    status?: "idle" | "running" | "disabled";
+    model?: string;
+    sharedSkillSnapshot?: {
+        id: string;
+        root: string;
+        manifestPath: string;
+        skills: string[];
+    } | null;
+    hostHomeEntries?: Array<{
+        name: string;
+        source: string;
+        target: string;
+        linked: boolean;
+        reason?: string;
+    }>;
+    workspaceRoot?: string;
+    worktreePlans?: WorktreePlan[];
+    worktreeMaterializationEnabled?: boolean;
+    runStats?: AgentRunStats;
+    tokenBudget?: TokenBudgetCheck;
+    remediation?: RemediationAdvice | null;
+    configWarnings?: AgentConfigWarning[];
+    updatedAt: string;
+};
+export type RunningState = {
+    version: string;
+    pid: number;
+    startedAt: string;
+    serverUrl?: string;
+    computerId?: string;
+    capabilities?: LocalCapabilities;
+    lastHeartbeatAt?: string;
+    lastSyncAt?: string;
+    agents?: RunningAgentState[];
+    events?: RunningEvent[];
+};
+export declare function daemonLogPath(): string;
+export declare function serviceNames(commandName?: CommandName): {
+    packageName: string;
+    serviceUnit: string;
+    displayName: string;
+    serviceLabel: string;
+};
+export declare function updateRegistryUrl(commandName?: CommandName): string;
+export declare function versionGt(a: string, b: string): boolean;
+export declare function windowsTaskName(commandName?: CommandName): string;
+export declare function windowsWrapperPath(commandName?: CommandName): string;
+export declare function buildWindowsServiceWrapper(args: string[], logPath?: string): string;
+export declare function parseWindowsTaskStatus(stdout: string): {
+    status?: string;
+    lastResult?: string;
+    taskName?: string;
+};
+export declare function shouldKillDaemonCommand(command: string): boolean;
+export declare function parseDarwinLaunchctlStatus(stdout: string): DarwinServiceStatus;
+export declare function parseLinuxMainPid(stdout: string): number | null;
+export declare function reloadService(commandName?: CommandName): Promise<void>;
+export declare function installService(serverUrl?: string, commandName?: CommandName): Promise<void>;
+export declare function uninstallService(commandName?: CommandName): Promise<void>;
+export declare function isServiceInstalled(commandName?: CommandName): boolean;
+export declare function restartService(commandName?: CommandName): Promise<void>;
+export declare function killRunningDaemons(): Promise<number>;
+export declare function stopService(commandName?: CommandName): Promise<void>;
+export declare function printStatus(commandName?: CommandName): Promise<void>;
+export declare function resolveRunningVersion(livePid?: number | null, commandName?: CommandName): Promise<string>;
+export declare function readRunningState(path?: string): Promise<RunningState | null>;
+export declare function updateRunningStateData(previous: RunningState | null, patch: Partial<Omit<RunningState, "events">> & {
+    event?: RunningEvent;
+}): RunningState;
+export declare function writeRunningState(patch?: Partial<Omit<RunningState, "events">> & {
+    event?: RunningEvent;
+}): Promise<void>;
+export declare function recordRunningState(patch: Partial<Omit<RunningState, "events">> & {
+    event?: RunningEvent;
+}): void;
+export declare function formatRecentRunningEvents(state: RunningState | null, max?: number): string;
+export declare function runningEventCategory(kind: string): RunningEventCategory;
+export declare function groupRunningEvents(events?: RunningEvent[], maxPerCategory?: number): Record<RunningEventCategory, RunningEvent[]>;
+export declare function formatRunningEventSummary(state: RunningState | null, maxPerCategory?: number): string;
+export declare function formatRunningStateSnapshot(state: RunningState | null, eventMax?: number): string;
+export declare function formatWatchSnapshot(state: RunningState | null, now?: Date): string;
+export declare function watchStatus(intervalMs?: number): Promise<void>;
+export declare function worktreePlansFromRunningState(state: RunningState | null): WorktreePlan[];
+export declare function prepareWorktrees(options?: {
+    execute?: boolean;
+}): Promise<void>;
+export declare function cleanupWorktrees(options?: {
+    execute?: boolean;
+}): Promise<void>;
+export declare function rotateLogsIfNeeded(logPath?: string, maxBytes?: number): Promise<void>;
+export declare function checkForUpdate(fetchImpl?: typeof fetch, commandName?: CommandName): Promise<string | null>;
+export declare function tailLogs(commandName?: CommandName): Promise<void>;