@spekn/cli 1.0.0

package/dist/tui/state/use-app-state.d.ts

@@ -0,0 +1,35 @@
+import type { BridgeSummary, DecisionListItem, ExportFormat, ExportPreview, LocalBridgeSummary, NavItemPolicy, SpecListItem, TuiBootContext, TuiScreenId, WorkflowSummary } from '../types';
+export interface TuiState {
+    boot: TuiBootContext | null;
+    client: any | null;
+    loading: boolean;
+    error: string | null;
+    screen: TuiScreenId;
+    navPolicy: NavItemPolicy[];
+    specs: SpecListItem[];
+    decisions: DecisionListItem[];
+    workflow: WorkflowSummary;
+    bridge: BridgeSummary | null;
+    localBridge: LocalBridgeSummary | null;
+    exportFormat: ExportFormat;
+    exportPreview: ExportPreview | null;
+    statusLine: string;
+    logs: string[];
+    searchQuery: string;
+    showHelp: boolean;
+    commandMode: boolean;
+}
+export declare function useAppState(apiUrl: string, initialScreen: TuiScreenId, projectId?: string): {
+    state: TuiState;
+    refresh: () => Promise<void>;
+    setScreen: (screen: TuiScreenId) => void;
+    toggleHelp: () => void;
+    setSearchQuery: (searchQuery: string) => void;
+    setCommandMode: (commandMode: boolean) => void;
+    setExportFormat: (exportFormat: ExportFormat) => void;
+    previewExport: () => Promise<void>;
+    generateExport: () => Promise<void>;
+    bridgeStart: () => void;
+    bridgeStop: () => Promise<void>;
+    appendLog: (entry: string) => void;
+};

package/dist/tui/state/use-app-state.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppState = useAppState;
+const react_1 = require("react");
+const policy_1 = require("../capabilities/policy");
+const context_service_1 = require("../services/context-service");
+const EMPTY_WORKFLOW = {
+    currentPhase: null,
+    blockedCount: 0,
+    hasPlanningArtifacts: false,
+    hasVerificationEvidence: false,
+};
+function useAppState(apiUrl, initialScreen, projectId) {
+    const service = (0, react_1.useMemo)(() => new context_service_1.TuiContextService(apiUrl), [apiUrl]);
+    const [state, setState] = (0, react_1.useState)({
+        boot: null,
+        client: null,
+        loading: true,
+        error: null,
+        screen: initialScreen,
+        navPolicy: [],
+        specs: [],
+        decisions: [],
+        workflow: EMPTY_WORKFLOW,
+        bridge: null,
+        localBridge: null,
+        exportFormat: 'claude-md',
+        exportPreview: null,
+        statusLine: 'Bootstrapping...',
+        logs: [],
+        searchQuery: '',
+        showHelp: false,
+        commandMode: false,
+    });
+    const appendLog = (0, react_1.useCallback)((entry) => {
+        setState((prev) => ({ ...prev, logs: [entry, ...prev.logs].slice(0, 40) }));
+    }, []);
+    const refresh = (0, react_1.useCallback)(async () => {
+        setState((prev) => ({ ...prev, loading: true, statusLine: 'Loading context...' }));
+        try {
+            const { boot, client } = await service.bootstrap(projectId);
+            const [specs, decisions, workflow, bridge, localBridge] = await Promise.all([
+                service.loadSpecs(client, boot.projectId),
+                service.loadDecisions(client, boot.projectId),
+                service.loadWorkflowSummary(client, boot.projectId),
+                service.loadBridgeSummary(client),
+                service.loadLocalBridgeSummary(),
+            ]);
+            const capabilityContext = {
+                plan: boot.plan,
+                role: boot.role,
+                workflowPhase: workflow.currentPhase,
+                permissions: boot.permissions,
+            };
+            const navPolicy = (0, policy_1.resolveNavPolicy)(capabilityContext);
+            setState((prev) => ({
+                ...prev,
+                boot,
+                client,
+                specs,
+                decisions,
+                workflow,
+                bridge,
+                localBridge,
+                navPolicy,
+                loading: false,
+                error: null,
+                statusLine: 'Ready',
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            setState((prev) => ({ ...prev, loading: false, error: message, statusLine: 'Error' }));
+            appendLog(`[error] ${message}`);
+        }
+    }, [appendLog, projectId, service]);
+    (0, react_1.useEffect)(() => {
+        void refresh();
+    }, [refresh]);
+    (0, react_1.useEffect)(() => {
+        const timer = setInterval(() => {
+            if (!state.client || !state.boot)
+                return;
+            void Promise.all([
+                service.loadWorkflowSummary(state.client, state.boot.projectId),
+                service.loadLocalBridgeSummary(),
+            ])
+                .then(([workflow, localBridge]) => {
+                setState((prev) => {
+                    const ctx = {
+                        plan: prev.boot?.plan ?? prev.navPolicy[0]?.requiredPlan ?? (prev.boot?.plan ?? 'free'),
+                        role: prev.boot?.role ?? 'member',
+                        workflowPhase: workflow.currentPhase,
+                        permissions: prev.boot?.permissions ?? [],
+                    };
+                    return {
+                        ...prev,
+                        workflow,
+                        localBridge,
+                        navPolicy: (0, policy_1.resolveNavPolicy)(ctx),
+                    };
+                });
+            })
+                .catch(() => undefined);
+        }, 6000);
+        return () => clearInterval(timer);
+    }, [service, state.boot, state.client, state.navPolicy]);
+    const setScreen = (0, react_1.useCallback)((screen) => {
+        setState((prev) => ({ ...prev, screen }));
+    }, []);
+    const toggleHelp = (0, react_1.useCallback)(() => {
+        setState((prev) => ({ ...prev, showHelp: !prev.showHelp }));
+    }, []);
+    const setSearchQuery = (0, react_1.useCallback)((searchQuery) => {
+        setState((prev) => ({ ...prev, searchQuery }));
+    }, []);
+    const setCommandMode = (0, react_1.useCallback)((commandMode) => {
+        setState((prev) => ({ ...prev, commandMode }));
+    }, []);
+    const setExportFormat = (0, react_1.useCallback)((exportFormat) => {
+        setState((prev) => ({ ...prev, exportFormat }));
+    }, []);
+    const previewExport = (0, react_1.useCallback)(async () => {
+        if (!state.client || !state.boot)
+            return;
+        setState((prev) => ({ ...prev, statusLine: 'Previewing export...' }));
+        try {
+            const preview = await service.previewExport(state.client, state.boot.projectId, state.exportFormat);
+            setState((prev) => ({ ...prev, exportPreview: preview, statusLine: 'Export preview ready' }));
+            appendLog(`[export] Previewed ${state.exportFormat} (${preview.anchorCount} anchors)`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            appendLog(`[error] Export preview failed: ${message}`);
+            setState((prev) => ({ ...prev, statusLine: 'Export preview failed' }));
+        }
+    }, [appendLog, service, state.boot, state.client, state.exportFormat]);
+    const generateExport = (0, react_1.useCallback)(async () => {
+        if (!state.client || !state.boot)
+            return;
+        setState((prev) => ({ ...prev, statusLine: 'Generating export...' }));
+        try {
+            const output = await service.generateExport(state.client, state.boot.projectId, state.exportFormat);
+            setState((prev) => ({ ...prev, exportPreview: output, statusLine: 'Export generated' }));
+            appendLog(`[export] Generated ${state.exportFormat} (${output.anchorCount} anchors)`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            appendLog(`[error] Export generation failed: ${message}`);
+            setState((prev) => ({ ...prev, statusLine: 'Export generation failed' }));
+        }
+    }, [appendLog, service, state.boot, state.client, state.exportFormat]);
+    const bridgeStart = (0, react_1.useCallback)(() => {
+        service.startLocalBridgeDetached();
+        appendLog('[bridge] Started local bridge process (detached)');
+        setState((prev) => ({ ...prev, statusLine: 'Bridge start triggered (detached)' }));
+    }, [appendLog, service]);
+    const bridgeStop = (0, react_1.useCallback)(async () => {
+        await service.stopLocalBridge(state.localBridge?.port);
+        appendLog('[bridge] Stop signal sent');
+        setState((prev) => ({ ...prev, statusLine: 'Bridge stop signal sent' }));
+    }, [appendLog, service, state.localBridge?.port]);
+    return {
+        state,
+        refresh,
+        setScreen,
+        toggleHelp,
+        setSearchQuery,
+        setCommandMode,
+        setExportFormat,
+        previewExport,
+        generateExport,
+        bridgeStart,
+        bridgeStop,
+        appendLog,
+    };
+}

package/dist/tui/types.d.ts

@@ -0,0 +1,77 @@
+import type { OrganizationPlan, WorkflowPhase } from './shared-enums';
+export type TuiScreenId = 'home' | 'specs' | 'export' | 'decisions' | 'bridge' | 'active-runs' | 'phase-gates' | 'skills-marketplace' | 'org-governance';
+export type TuiRole = 'owner' | 'admin' | 'member' | 'viewer';
+export type ActionState = 'enabled' | 'disabled' | 'locked';
+export interface CapabilityContext {
+    plan: OrganizationPlan;
+    role: TuiRole;
+    workflowPhase: WorkflowPhase | null;
+    permissions: string[];
+}
+export interface NavItemPolicy {
+    id: TuiScreenId;
+    label: string;
+    description: string;
+    requiredPlan: OrganizationPlan;
+    state: ActionState;
+    reason?: string;
+}
+export interface TuiBootContext {
+    apiUrl: string;
+    organizationId: string;
+    organizationName: string;
+    role: TuiRole;
+    plan: OrganizationPlan;
+    projectId: string;
+    projectName: string;
+    permissions: string[];
+}
+export interface SpecListItem {
+    id: string;
+    title: string;
+    status: string;
+    version: string;
+    updatedAt?: string;
+    type?: string;
+}
+export interface DecisionListItem {
+    id: string;
+    title: string;
+    status: string;
+    decisionType: string;
+    specAnchor?: string | null;
+    createdAt?: string;
+}
+export interface WorkflowSummary {
+    currentPhase: WorkflowPhase | null;
+    blockedCount: number;
+    hasVerificationEvidence: boolean;
+    hasPlanningArtifacts: boolean;
+}
+export interface BridgeSummary {
+    featureEnabled: boolean;
+    devices: Array<{
+        id: string;
+        name: string;
+        status: string;
+        isDefault: boolean;
+        lastSeenAt?: string | null;
+    }>;
+    connectedDevices: number;
+    authFailures: number;
+}
+export interface LocalBridgeSummary {
+    paired: boolean;
+    deviceId?: string;
+    deviceName?: string;
+    port: number;
+    running: boolean;
+    uptimeSec?: number;
+}
+export type ExportFormat = 'claude-md' | 'cursorrules';
+export interface ExportPreview {
+    content: string;
+    anchorCount: number;
+    specVersion?: string;
+    warnings?: string[];
+}

package/dist/tui/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tui-bundle.d.ts

@@ -0,0 +1 @@
+export { runTuiCli } from "@spekn/tui";

package/dist/tui-bundle.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTuiCli = void 0;
+var tui_1 = require("@spekn/tui");
+Object.defineProperty(exports, "runTuiCli", { enumerable: true, get: function () { return tui_1.runTuiCli; } });