hydra-os-cli 0.1.0

package/dist/clients/api.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Hydra API client.
+ * REST calls to the hydra-api service on :7070.
+ */
+export interface WorkflowStartResponse {
+    workflow_id: string;
+    run_id: string;
+    status: string;
+}
+export interface WorkflowStatusResponse {
+    workflow_id: string;
+    status: Record<string, unknown>;
+}
+export interface WorkflowResponse {
+    id: string;
+    workflow_type: string;
+    status: string;
+    current_step: string | null;
+    steps: Array<Record<string, unknown>>;
+    input: Record<string, unknown>;
+    output: Record<string, unknown> | null;
+    artifacts: Array<Record<string, unknown>>;
+    created_at: string;
+    updated_at: string;
+    workspace_id: string;
+    project: string | null;
+    metrics: Record<string, unknown> | null;
+}
+export interface TaskSummary {
+    workflow_id: string;
+    workflow_type: string;
+    task_description: string | null;
+    status: string;
+    domain: string | null;
+    technologies: string[] | null;
+    complexity: string | null;
+    created_at: string;
+    completed_at: string | null;
+    duration_minutes: number | null;
+    current_step: string | null;
+    completed_steps: string[] | null;
+}
+export interface InboxItemResponse {
+    id: string;
+    type: string;
+    workflow_id: string;
+    workflow_type: string;
+    title: string;
+    summary: string;
+    priority: string;
+    created_at: string;
+    agent_role: string | null;
+    agent_recommendation: string | null;
+    approval_type: string;
+    artifact_path: string | null;
+    status: string;
+}
+export interface AgentResponse {
+    id: string;
+    role_id: string;
+    queue: string;
+    status: string;
+    model: string;
+    active_sessions: number;
+    total_tokens_used: number;
+    current_workflow: string | null;
+    skill_packs: string[];
+    allowed_tools: string[];
+}
+export interface WorkflowControlResponse {
+    workflow_id: string;
+    action: string;
+    status: string;
+    temporal_status: string | null;
+    message: string | null;
+}
+export interface MemorySearchResult {
+    results: Array<Record<string, unknown>>;
+    total: number;
+    has_more: boolean;
+}
+export interface HealthResponse {
+    status: string;
+    version?: string;
+    [key: string]: unknown;
+}
+export declare class HydraApiClient {
+    private baseUrl;
+    constructor(baseUrl?: string);
+    private request;
+    startWorkflow(workflowType: string, workflowId: string, input: Record<string, unknown>): Promise<WorkflowStartResponse>;
+    getWorkflow(workflowId: string): Promise<WorkflowResponse>;
+    getWorkflowStatus(workflowId: string): Promise<WorkflowStatusResponse>;
+    listTasks(filters?: {
+        status?: string;
+        workflow_type?: string;
+        domain?: string;
+        limit?: number;
+    }): Promise<TaskSummary[]>;
+    approveWorkflow(workflowId: string, decision: string, feedback?: string): Promise<Record<string, unknown>>;
+    cancelWorkflow(workflowId: string, reason?: string): Promise<WorkflowControlResponse>;
+    pauseWorkflow(workflowId: string, reason?: string): Promise<WorkflowControlResponse>;
+    resumeWorkflow(workflowId: string, reason?: string): Promise<WorkflowControlResponse>;
+    getInbox(): Promise<InboxItemResponse[]>;
+    approveInboxItem(itemId: string, body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    rejectInboxItem(itemId: string, body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getAgents(): Promise<{
+        agents: AgentResponse[];
+    }>;
+    searchMemory(query: string, collections?: string[], limit?: number): Promise<MemorySearchResult>;
+    getRoles(): Promise<Record<string, unknown>>;
+    getArtifactContent(workflowId: string, filePath: string): Promise<string>;
+    healthCheck(): Promise<HealthResponse>;
+}
+export declare function getApiClient(baseUrl?: string): HydraApiClient;

package/dist/clients/api.js

@@ -0,0 +1,123 @@
+/**
+ * Hydra API client.
+ * REST calls to the hydra-api service on :7070.
+ */
+class ApiError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "ApiError";
+    }
+}
+export class HydraApiClient {
+    baseUrl;
+    constructor(baseUrl = "http://localhost:7070") {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+    }
+    async request(method, path, body, params) {
+        let url = `${this.baseUrl}${path}`;
+        if (params) {
+            const qs = new URLSearchParams(params).toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        const headers = {};
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            let detail = text;
+            try {
+                const json = JSON.parse(text);
+                detail = json.detail || text;
+            }
+            catch { /* use raw text */ }
+            throw new ApiError(res.status, `${method} ${path}: ${res.status} ${detail}`);
+        }
+        const contentType = res.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+            return (await res.json());
+        }
+        return (await res.text());
+    }
+    async startWorkflow(workflowType, workflowId, input) {
+        return this.request("POST", "/workflows/start", {
+            workflow_type: workflowType,
+            workflow_id: workflowId,
+            input,
+        });
+    }
+    async getWorkflow(workflowId) {
+        return this.request("GET", `/workflows/${workflowId}`);
+    }
+    async getWorkflowStatus(workflowId) {
+        return this.request("GET", `/workflows/${workflowId}/status`);
+    }
+    async listTasks(filters) {
+        const params = {};
+        if (filters?.status)
+            params.status = filters.status;
+        if (filters?.workflow_type)
+            params.workflow_type = filters.workflow_type;
+        if (filters?.domain)
+            params.domain = filters.domain;
+        if (filters?.limit)
+            params.limit = String(filters.limit);
+        return this.request("GET", "/tasks", undefined, params);
+    }
+    async approveWorkflow(workflowId, decision, feedback) {
+        return this.request("POST", `/workflows/${workflowId}/approve`, { decision, feedback });
+    }
+    async cancelWorkflow(workflowId, reason) {
+        return this.request("POST", `/workflows/${workflowId}/cancel`, reason ? { reason } : undefined);
+    }
+    async pauseWorkflow(workflowId, reason) {
+        return this.request("POST", `/workflows/${workflowId}/pause`, reason ? { reason } : undefined);
+    }
+    async resumeWorkflow(workflowId, reason) {
+        return this.request("POST", `/workflows/${workflowId}/resume`, reason ? { reason } : undefined);
+    }
+    async getInbox() {
+        return this.request("GET", "/inbox");
+    }
+    async approveInboxItem(itemId, body) {
+        return this.request("POST", `/inbox/${itemId}/approve`, body);
+    }
+    async rejectInboxItem(itemId, body) {
+        return this.request("POST", `/inbox/${itemId}/reject`, body);
+    }
+    async getAgents() {
+        return this.request("GET", "/agents");
+    }
+    async searchMemory(query, collections, limit) {
+        return this.request("POST", "/memory/search", {
+            query,
+            collections,
+            limit: limit ?? 10,
+            offset: 0,
+        });
+    }
+    async getRoles() {
+        return this.request("GET", "/config/roles");
+    }
+    async getArtifactContent(workflowId, filePath) {
+        return this.request("GET", `/artifacts/${workflowId}/${filePath}`);
+    }
+    async healthCheck() {
+        return this.request("GET", "/");
+    }
+}
+let _client = null;
+export function getApiClient(baseUrl) {
+    if (!_client || (baseUrl && baseUrl !== _client["baseUrl"])) {
+        _client = new HydraApiClient(baseUrl);
+    }
+    return _client;
+}

package/dist/clients/qdrant.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Qdrant client wrapper.
+ * Memory search and artifact lookup via Qdrant vector DB.
+ */
+export interface MemoryResult {
+    id: string;
+    content: string;
+    role?: string;
+    workflowId?: string;
+    timestamp: string;
+    score: number;
+    pinned: boolean;
+}
+export interface DecisionResult {
+    id: string;
+    decision: string;
+    alternatives: string[];
+    rationale: string;
+    outcome?: string;
+    workflowId?: string;
+    timestamp: string;
+}
+export declare class QdrantClient {
+    private url;
+    constructor(url?: string);
+    searchMemories(_query: string, _limit?: number): Promise<MemoryResult[]>;
+    addMemory(_content: string, _options?: {
+        pin?: boolean;
+        role?: string;
+        workflowId?: string;
+    }): Promise<string>;
+    pinMemory(_id: string): Promise<void>;
+    deleteMemory(_id: string): Promise<void>;
+    getDecisions(_workflowId?: string): Promise<DecisionResult[]>;
+    getMemoryStats(): Promise<{
+        decisions: number;
+        facts: number;
+    }>;
+}

package/dist/clients/qdrant.js

@@ -0,0 +1,34 @@
+/**
+ * Qdrant client wrapper.
+ * Memory search and artifact lookup via Qdrant vector DB.
+ */
+export class QdrantClient {
+    url;
+    constructor(url = "http://localhost:6333") {
+        this.url = url;
+    }
+    async searchMemories(_query, _limit) {
+        // TODO: search `memories` collection
+        throw new Error("Not implemented");
+    }
+    async addMemory(_content, _options) {
+        // TODO: upsert to `memories` collection
+        throw new Error("Not implemented");
+    }
+    async pinMemory(_id) {
+        // TODO: update payload.pinned = true
+        throw new Error("Not implemented");
+    }
+    async deleteMemory(_id) {
+        // TODO: delete from `memories` collection
+        throw new Error("Not implemented");
+    }
+    async getDecisions(_workflowId) {
+        // TODO: search `decisions` collection
+        throw new Error("Not implemented");
+    }
+    async getMemoryStats() {
+        // TODO: count from collections
+        throw new Error("Not implemented");
+    }
+}

package/dist/clients/temporal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Temporal client wrapper.
+ * Connects to Temporal to start workflows, send signals, query state, and list workflows.
+ */
+export interface WorkflowInfo {
+    workflowId: string;
+    runId: string;
+    status: string;
+    taskQueue: string;
+    startTime: Date;
+}
+export interface WorkflowState {
+    phase: string;
+    currentAgent?: string;
+    approvalPending: boolean;
+    steps: StepState[];
+    totalCost: number;
+    totalTokens: number;
+}
+export interface StepState {
+    role: string;
+    status: "done" | "running" | "waiting" | "pending" | "failed";
+    startTime?: Date;
+    endTime?: Date;
+    score?: number;
+    cost?: number;
+}
+export declare class TemporalClient {
+    private address;
+    private namespace;
+    constructor(address?: string, namespace?: string);
+    startWorkflow(_description: string): Promise<string>;
+    getWorkflowStatus(_workflowId: string): Promise<WorkflowState>;
+    listWorkflows(): Promise<WorkflowInfo[]>;
+    signalWorkflow(_workflowId: string, _signalName: string, _payload: unknown): Promise<void>;
+    cancelWorkflow(_workflowId: string): Promise<void>;
+}

package/dist/clients/temporal.js

@@ -0,0 +1,32 @@
+/**
+ * Temporal client wrapper.
+ * Connects to Temporal to start workflows, send signals, query state, and list workflows.
+ */
+export class TemporalClient {
+    address;
+    namespace;
+    constructor(address = "localhost:7233", namespace = "default") {
+        this.address = address;
+        this.namespace = namespace;
+    }
+    async startWorkflow(_description) {
+        // TODO: implement via Temporal SDK or API proxy
+        throw new Error("Not implemented");
+    }
+    async getWorkflowStatus(_workflowId) {
+        // TODO: implement via Temporal query
+        throw new Error("Not implemented");
+    }
+    async listWorkflows() {
+        // TODO: implement via Temporal visibility
+        throw new Error("Not implemented");
+    }
+    async signalWorkflow(_workflowId, _signalName, _payload) {
+        // TODO: implement via Temporal signal
+        throw new Error("Not implemented");
+    }
+    async cancelWorkflow(_workflowId) {
+        // TODO: implement via Temporal cancel
+        throw new Error("Not implemented");
+    }
+}

package/dist/commands/agent.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Agent commands: /agents, /agent, /logs, /signal
+ */
+export declare function registerAgentCommands(): void;

package/dist/commands/agent.js

@@ -0,0 +1,103 @@
+/**
+ * Agent commands: /agents, /agent, /logs, /signal
+ */
+import { registerCommand } from "./registry.js";
+export function registerAgentCommands() {
+    registerCommand({
+        name: "agents",
+        description: "List all agent roles and their status",
+        usage: "/agents",
+        category: "agent",
+        handler: async ({ store, api }) => {
+            try {
+                const resp = await api.getAgents();
+                const agents = resp.agents;
+                if (agents.length === 0) {
+                    store.addMessage({ role: "system", content: "No agents registered." });
+                    return;
+                }
+                // Update store
+                store.setAgents(agents.map((a) => ({
+                    id: a.id,
+                    role_id: a.role_id,
+                    queue: a.queue,
+                    status: a.status,
+                    model: a.model,
+                    active_sessions: a.active_sessions,
+                    total_tokens_used: a.total_tokens_used,
+                    current_workflow: a.current_workflow,
+                    skill_packs: a.skill_packs,
+                })));
+                const lines = ["Agents:\n"];
+                lines.push("  Role              | Status  | Model                      | Workflow");
+                lines.push("  " + "-".repeat(80));
+                for (const a of agents) {
+                    const role = a.role_id.padEnd(17);
+                    const status = a.status.padEnd(7);
+                    const model = (a.model ?? "").slice(0, 26).padEnd(26);
+                    const wf = a.current_workflow ?? "-";
+                    lines.push(`  ${role} | ${status} | ${model} | ${wf}`);
+                }
+                store.addMessage({ role: "system", content: lines.join("\n") });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                store.addMessage({ role: "error", content: `Failed to get agents: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "agent",
+        description: "Show details for a specific agent role",
+        usage: "/agent <role>",
+        category: "agent",
+        handler: async ({ store, api, args }) => {
+            const role = args[0];
+            if (!role) {
+                store.addMessage({ role: "error", content: "Usage: /agent <role>" });
+                return;
+            }
+            try {
+                const resp = await api.getAgents();
+                const agent = resp.agents.find((a) => a.role_id === role || a.id === role);
+                if (!agent) {
+                    store.addMessage({ role: "error", content: `Agent not found: ${role}` });
+                    return;
+                }
+                const lines = [
+                    `Agent: ${agent.role_id}`,
+                    `  Status: ${agent.status}`,
+                    `  Model: ${agent.model}`,
+                    `  Queue: ${agent.queue}`,
+                    `  Active sessions: ${agent.active_sessions}`,
+                    `  Total tokens: ${agent.total_tokens_used}`,
+                    `  Current workflow: ${agent.current_workflow ?? "none"}`,
+                    `  Skills: ${agent.skill_packs.join(", ") || "none"}`,
+                ];
+                store.addMessage({ role: "system", content: lines.join("\n") });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                store.addMessage({ role: "error", content: `Failed to get agent: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "logs",
+        description: "Stream logs from a specific agent",
+        usage: "/logs <role>",
+        category: "agent",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Log streaming is not yet available (Phase 2)." });
+        },
+    });
+    registerCommand({
+        name: "signal",
+        description: "Send a signal to a specific agent",
+        usage: "/signal <role> <message>",
+        category: "agent",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Signal is not yet available (Phase 2)." });
+        },
+    });
+}

package/dist/commands/artifact.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Artifact commands: /artifacts, /artifact, /diff, /export
+ */
+export declare function registerArtifactCommands(): void;

package/dist/commands/artifact.js

@@ -0,0 +1,42 @@
+/**
+ * Artifact commands: /artifacts, /artifact, /diff, /export
+ */
+import { registerCommand } from "./registry.js";
+export function registerArtifactCommands() {
+    registerCommand({
+        name: "artifacts",
+        description: "List artifacts for a workflow",
+        usage: "/artifacts [workflow-id]",
+        category: "artifact",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Artifact listing is not yet available (Phase 3)." });
+        },
+    });
+    registerCommand({
+        name: "artifact",
+        description: "Display artifact content",
+        usage: "/artifact <path>",
+        category: "artifact",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Artifact display is not yet available (Phase 3)." });
+        },
+    });
+    registerCommand({
+        name: "diff",
+        description: "Show diff for a file artifact",
+        usage: "/diff <artifact>",
+        category: "artifact",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Diff is not yet available (Phase 3)." });
+        },
+    });
+    registerCommand({
+        name: "export",
+        description: "Export all artifacts to a directory",
+        usage: "/export <workflow-id> <dir>",
+        category: "artifact",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Export is not yet available (Phase 3)." });
+        },
+    });
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Configuration commands: /config, /roles, /skills, /model, /cost, /theme
+ */
+export declare function registerConfigCommands(): void;

package/dist/commands/config.js

@@ -0,0 +1,80 @@
+/**
+ * Configuration commands: /config, /roles, /skills, /model, /cost, /theme
+ */
+import { registerCommand } from "./registry.js";
+export function registerConfigCommands() {
+    registerCommand({
+        name: "config",
+        description: "Open settings",
+        usage: "/config",
+        category: "config",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Config editor is not yet available (Phase 2)." });
+        },
+    });
+    registerCommand({
+        name: "roles",
+        description: "Show role catalog from config/roles.yaml",
+        usage: "/roles",
+        category: "config",
+        handler: async ({ store, api }) => {
+            try {
+                const data = await api.getRoles();
+                const roles = data.roles;
+                if (!Array.isArray(roles) || roles.length === 0) {
+                    store.addMessage({ role: "system", content: "No roles configured." });
+                    return;
+                }
+                const lines = ["Role catalog:\n"];
+                for (const r of roles) {
+                    const role = r;
+                    const id = String(role.id ?? "unknown");
+                    const queue = String(role.queue ?? id);
+                    const skills = Array.isArray(role.skill_packs) ? role.skill_packs.join(", ") : "";
+                    lines.push(`  ${id.padEnd(18)} queue=${queue.padEnd(18)} skills=[${skills}]`);
+                }
+                store.addMessage({ role: "system", content: lines.join("\n") });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                store.addMessage({ role: "error", content: `Failed to get roles: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "skills",
+        description: "List available skills",
+        usage: "/skills",
+        category: "config",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Skills listing is not yet available (Phase 2)." });
+        },
+    });
+    registerCommand({
+        name: "model",
+        description: "Set model for new agent sessions",
+        usage: "/model <model-name>",
+        category: "config",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Model selection is not yet available (Phase 2)." });
+        },
+    });
+    registerCommand({
+        name: "cost",
+        description: "Show cumulative cost across all workflows",
+        usage: "/cost",
+        category: "config",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Cost tracking is not yet available (Phase 2)." });
+        },
+    });
+    registerCommand({
+        name: "theme",
+        description: "Switch theme",
+        usage: "/theme <name>",
+        category: "config",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Theme switching is not yet available (Phase 2)." });
+        },
+    });
+}

package/dist/commands/core.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Core commands: /help, /clear, /compact, /doctor
+ */
+export declare function registerCoreCommands(): void;