@plures/praxis 1.0.2 → 1.1.0

package/dist/{src → browser}/integrations/svelte.d.ts

@@ -1,3 +1,5 @@
+import { L as LogicEngine, P as PraxisState, a as PraxisEvent } from '../engine-BjdqxeXG.js';
+
 /**
  * Svelte v5 Integration
  *
@@ -11,12 +13,11 @@
  * - History state pattern implementation
  * - Automatic cleanup and subscription management
  */
-import type { LogicEngine } from "../core/engine.js";
-import type { PraxisEvent, PraxisState } from "../core/protocol.js";
+
 /**
  * Writable store interface (Svelte-compatible)
  */
-export interface Writable<T> {
+interface Writable<T> {
     subscribe(run: (value: T) => void): () => void;
     set(value: T): void;
     update(updater: (value: T) => T): void;
@@ -24,7 +25,7 @@ export interface Writable<T> {
 /**
  * Readable store interface (Svelte-compatible)
  */
-export interface Readable<T> {
+interface Readable<T> {
     subscribe(run: (value: T) => void): () => void;
 }
 /**
@@ -42,7 +43,7 @@ export interface Readable<T> {
  * // Dispatch events:
  * store.dispatch([Login.create({ username: "alice", password: "secret" })]);
  */
-export declare function createPraxisStore<TContext = unknown>(engine: LogicEngine<TContext>): Readable<Readonly<PraxisState & {
+declare function createPraxisStore<TContext = unknown>(engine: LogicEngine<TContext>): Readable<Readonly<PraxisState & {
     context: TContext;
 }>> & {
     dispatch: (events: PraxisEvent[]) => void;
@@ -57,7 +58,7 @@ export declare function createPraxisStore<TContext = unknown>(engine: LogicEngin
  * // In Svelte component:
  * $: context = $contextStore;
  */
-export declare function createContextStore<TContext = unknown>(engine: LogicEngine<TContext>): Readable<TContext> & {
+declare function createContextStore<TContext = unknown>(engine: LogicEngine<TContext>): Readable<TContext> & {
     dispatch: (events: PraxisEvent[]) => void;
 };
 /**
@@ -70,13 +71,13 @@ export declare function createContextStore<TContext = unknown>(engine: LogicEngi
  * // In Svelte component:
  * $: count = $countStore;
  */
-export declare function createDerivedStore<TContext = unknown, TDerived = unknown>(engine: LogicEngine<TContext>, selector: (context: TContext) => TDerived): Readable<TDerived> & {
+declare function createDerivedStore<TContext = unknown, TDerived = unknown>(engine: LogicEngine<TContext>, selector: (context: TContext) => TDerived): Readable<TDerived> & {
     dispatch: (events: PraxisEvent[]) => void;
 };
 /**
  * Snapshot of engine state for time-travel debugging
  */
-export interface StateSnapshot<TContext = unknown> {
+interface StateSnapshot<TContext = unknown> {
     timestamp: number;
     state: Readonly<PraxisState & {
         context: TContext;
@@ -86,7 +87,7 @@ export interface StateSnapshot<TContext = unknown> {
 /**
  * Options for usePraxisEngine composable
  */
-export interface UsePraxisEngineOptions {
+interface UsePraxisEngineOptions {
     /** Enable snapshot history for time-travel debugging */
     enableHistory?: boolean;
     /** Maximum number of snapshots to keep */
@@ -95,7 +96,7 @@ export interface UsePraxisEngineOptions {
 /**
  * Result of usePraxisEngine composable with Svelte 5 runes
  */
-export interface PraxisEngineBinding<TContext = unknown> {
+interface PraxisEngineBinding<TContext = unknown> {
     /** Current state (reactive via $state) */
     state: Readonly<PraxisState & {
         context: TContext;
@@ -155,7 +156,7 @@ export interface PraxisEngineBinding<TContext = unknown> {
  * @param options Configuration options
  * @returns Reactive binding with state, context, and control methods
  */
-export declare function usePraxisEngine<TContext = unknown>(engine: LogicEngine<TContext>, options?: UsePraxisEngineOptions): PraxisEngineBinding<TContext>;
+declare function usePraxisEngine<TContext = unknown>(engine: LogicEngine<TContext>, options?: UsePraxisEngineOptions): PraxisEngineBinding<TContext>;
 /**
  * Create a reactive derived value from engine context with Svelte 5 runes.
  *
@@ -176,7 +177,7 @@ export declare function usePraxisEngine<TContext = unknown>(engine: LogicEngine<
  * @param selector Function to extract value from context
  * @returns Reactive derived value
  */
-export declare function usePraxisContext<TContext = unknown, TDerived = unknown>(engine: LogicEngine<TContext>, selector: (context: TContext) => TDerived): TDerived;
+declare function usePraxisContext<TContext = unknown, TDerived = unknown>(engine: LogicEngine<TContext>, selector: (context: TContext) => TDerived): TDerived;
 /**
  * Subscribe to engine state changes with automatic cleanup.
  *
@@ -197,13 +198,13 @@ export declare function usePraxisContext<TContext = unknown, TDerived = unknown>
  * @param engine The Praxis logic engine
  * @param callback Function to call when state changes
  */
-export declare function usePraxisSubscription<TContext = unknown>(engine: LogicEngine<TContext>, callback: (state: Readonly<PraxisState & {
+declare function usePraxisSubscription<TContext = unknown>(engine: LogicEngine<TContext>, callback: (state: Readonly<PraxisState & {
     context: TContext;
 }>) => void): () => void;
 /**
  * History state entry for tracking state transitions
  */
-export interface HistoryEntry<TContext = unknown> {
+interface HistoryEntry<TContext = unknown> {
     /** Unique identifier for this history entry */
     id: string;
     /** Timestamp when this state was entered */
@@ -220,7 +221,7 @@ export interface HistoryEntry<TContext = unknown> {
 /**
  * History state manager for Praxis engines
  */
-export declare class HistoryStateManager<TContext = unknown> {
+declare class HistoryStateManager<TContext = unknown> {
     private history;
     private currentIndex;
     private readonly maxSize;
@@ -289,7 +290,7 @@ export declare class HistoryStateManager<TContext = unknown> {
  * @param options History configuration
  * @returns Enhanced engine with history methods
  */
-export declare function createHistoryEngine<TContext = unknown>(engine: LogicEngine<TContext>, options?: {
+declare function createHistoryEngine<TContext = unknown>(engine: LogicEngine<TContext>, options?: {
     maxHistorySize?: number;
     initialLabel?: string;
 }): {
@@ -303,4 +304,5 @@ export declare function createHistoryEngine<TContext = unknown>(engine: LogicEng
     goToHistory: (index: number) => boolean;
     clearHistory: () => void;
 };
-//# sourceMappingURL=svelte.d.ts.map
+
+export { type HistoryEntry, HistoryStateManager, type PraxisEngineBinding, type Readable, type StateSnapshot, type UsePraxisEngineOptions, type Writable, createContextStore, createDerivedStore, createHistoryEngine, createPraxisStore, usePraxisContext, usePraxisEngine, usePraxisSubscription };

package/dist/browser/integrations/svelte.js

@@ -0,0 +1,298 @@
+// src/integrations/svelte.ts
+function createPraxisStore(engine) {
+  let currentState = engine.getState();
+  const subscribers = /* @__PURE__ */ new Set();
+  const notify = () => {
+    currentState = engine.getState();
+    subscribers.forEach((sub) => sub(currentState));
+  };
+  return {
+    subscribe(run) {
+      subscribers.add(run);
+      run(currentState);
+      return () => {
+        subscribers.delete(run);
+      };
+    },
+    dispatch(events) {
+      engine.step(events);
+      notify();
+    }
+  };
+}
+function createContextStore(engine) {
+  let currentContext = engine.getContext();
+  const subscribers = /* @__PURE__ */ new Set();
+  const notify = () => {
+    currentContext = engine.getContext();
+    subscribers.forEach((sub) => sub(currentContext));
+  };
+  return {
+    subscribe(run) {
+      subscribers.add(run);
+      run(currentContext);
+      return () => {
+        subscribers.delete(run);
+      };
+    },
+    dispatch(events) {
+      engine.step(events);
+      notify();
+    }
+  };
+}
+function createDerivedStore(engine, selector) {
+  let currentValue = selector(engine.getContext());
+  const subscribers = /* @__PURE__ */ new Set();
+  const notify = () => {
+    const newValue = selector(engine.getContext());
+    if (newValue !== currentValue) {
+      currentValue = newValue;
+      subscribers.forEach((sub) => sub(currentValue));
+    }
+  };
+  return {
+    subscribe(run) {
+      subscribers.add(run);
+      run(currentValue);
+      return () => {
+        subscribers.delete(run);
+      };
+    },
+    dispatch(events) {
+      engine.step(events);
+      notify();
+    }
+  };
+}
+function usePraxisEngine(engine, options = {}) {
+  const { enableHistory = false, maxHistorySize = 50 } = options;
+  let currentState = engine.getState();
+  let snapshots = [];
+  let historyIndex = -1;
+  if (enableHistory) {
+    snapshots.push({
+      timestamp: Date.now(),
+      state: currentState,
+      events: []
+    });
+    historyIndex = 0;
+  }
+  const dispatch = (events) => {
+    if (enableHistory && historyIndex < snapshots.length - 1) {
+      snapshots = snapshots.slice(0, historyIndex + 1);
+    }
+    engine.step(events);
+    currentState = engine.getState();
+    if (enableHistory) {
+      snapshots.push({
+        timestamp: Date.now(),
+        state: currentState,
+        events
+      });
+      if (snapshots.length > maxHistorySize) {
+        snapshots.shift();
+      } else {
+        historyIndex++;
+      }
+    }
+  };
+  const goToSnapshot = (index) => {
+    if (!enableHistory) {
+      console.warn("History is not enabled for this engine");
+      return;
+    }
+    if (index < 0 || index >= snapshots.length) {
+      console.warn(`Invalid snapshot index: ${index}`);
+      return;
+    }
+    historyIndex = index;
+    currentState = snapshots[index].state;
+  };
+  const undo = () => {
+    if (historyIndex > 0) {
+      goToSnapshot(historyIndex - 1);
+    }
+  };
+  const redo = () => {
+    if (historyIndex < snapshots.length - 1) {
+      goToSnapshot(historyIndex + 1);
+    }
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    get context() {
+      return currentState.context;
+    },
+    get facts() {
+      return currentState.facts;
+    },
+    dispatch,
+    get snapshots() {
+      return snapshots;
+    },
+    goToSnapshot,
+    undo,
+    redo,
+    get canUndo() {
+      return enableHistory && historyIndex > 0;
+    },
+    get canRedo() {
+      return enableHistory && historyIndex < snapshots.length - 1;
+    },
+    get historyIndex() {
+      return historyIndex;
+    }
+  };
+}
+function usePraxisContext(engine, selector) {
+  let currentValue = selector(engine.getContext());
+  return currentValue;
+}
+function usePraxisSubscription(engine, callback) {
+  const store = createPraxisStore(engine);
+  const unsubscribe = store.subscribe(callback);
+  return unsubscribe;
+}
+var HistoryStateManager = class {
+  history = [];
+  currentIndex = -1;
+  maxSize;
+  idCounter = 0;
+  constructor(maxSize = 50) {
+    this.maxSize = maxSize;
+  }
+  /**
+   * Record a new history entry
+   */
+  record(state, events, label) {
+    if (this.currentIndex < this.history.length - 1) {
+      this.history = this.history.slice(0, this.currentIndex + 1);
+    }
+    this.history.push({
+      id: `history-${++this.idCounter}`,
+      timestamp: Date.now(),
+      state,
+      events,
+      label
+    });
+    if (this.history.length > this.maxSize) {
+      this.history.shift();
+    } else {
+      this.currentIndex++;
+    }
+  }
+  /**
+   * Navigate to a specific history entry
+   */
+  goTo(index) {
+    if (index < 0 || index >= this.history.length) {
+      return null;
+    }
+    this.currentIndex = index;
+    return this.history[index];
+  }
+  /**
+   * Go back to previous state
+   */
+  back() {
+    if (!this.canGoBack()) {
+      return null;
+    }
+    return this.goTo(this.currentIndex - 1);
+  }
+  /**
+   * Go forward to next state
+   */
+  forward() {
+    if (!this.canGoForward()) {
+      return null;
+    }
+    return this.goTo(this.currentIndex + 1);
+  }
+  /**
+   * Check if can go back
+   */
+  canGoBack() {
+    return this.currentIndex > 0;
+  }
+  /**
+   * Check if can go forward
+   */
+  canGoForward() {
+    return this.currentIndex < this.history.length - 1;
+  }
+  /**
+   * Get current history entry
+   */
+  current() {
+    if (this.currentIndex < 0 || this.currentIndex >= this.history.length) {
+      return null;
+    }
+    return this.history[this.currentIndex];
+  }
+  /**
+   * Get all history entries
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * Get current index in history
+   */
+  getCurrentIndex() {
+    return this.currentIndex;
+  }
+  /**
+   * Clear all history
+   */
+  clear() {
+    this.history = [];
+    this.currentIndex = -1;
+  }
+};
+function createHistoryEngine(engine, options = {}) {
+  const history = new HistoryStateManager(options.maxHistorySize);
+  history.record(engine.getState(), [], options.initialLabel || "Initial");
+  const dispatch = (events, label) => {
+    engine.step(events);
+    history.record(engine.getState(), events, label);
+  };
+  const undo = () => {
+    const entry = history.back();
+    if (entry) {
+      return true;
+    }
+    return false;
+  };
+  const redo = () => {
+    const entry = history.forward();
+    if (entry) {
+      return true;
+    }
+    return false;
+  };
+  return {
+    engine,
+    dispatch,
+    undo,
+    redo,
+    canUndo: () => history.canGoBack(),
+    canRedo: () => history.canGoForward(),
+    getHistory: () => history.getHistory(),
+    goToHistory: (index) => history.goTo(index) !== null,
+    clearHistory: () => history.clear()
+  };
+}
+export {
+  HistoryStateManager,
+  createContextStore,
+  createDerivedStore,
+  createHistoryEngine,
+  createPraxisStore,
+  usePraxisContext,
+  usePraxisEngine,
+  usePraxisSubscription
+};

package/dist/node/auth-STARLY7I.js

@@ -0,0 +1,207 @@
+import {
+  createSponsorsClient
+} from "./chunk-DSDC2JWZ.js";
+import {
+  authenticateWithDeviceFlow
+} from "./chunk-FXQZXAWF.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/cli/commands/auth.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var AUTH_DIR = path.join(os.homedir(), ".praxis");
+var AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+var GITHUB_CLIENT_ID = "Ov23liQxF7P0BqUxVXHk";
+function loadAuth() {
+  try {
+    if (fs.existsSync(AUTH_FILE)) {
+      const data = fs.readFileSync(AUTH_FILE, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    console.warn("Failed to load authentication:", error);
+  }
+  return null;
+}
+function saveAuth(auth) {
+  try {
+    if (!fs.existsSync(AUTH_DIR)) {
+      fs.mkdirSync(AUTH_DIR, { recursive: true });
+    }
+    fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), { mode: 384 });
+    console.log(`
+\u2713 Authentication saved to ${AUTH_FILE}`);
+  } catch (error) {
+    console.error("Failed to save authentication:", error);
+    throw error;
+  }
+}
+function deleteAuth() {
+  try {
+    if (fs.existsSync(AUTH_FILE)) {
+      fs.unlinkSync(AUTH_FILE);
+    }
+  } catch (error) {
+    console.warn("Failed to delete authentication:", error);
+  }
+}
+async function loginCommand(options) {
+  console.log("\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.log("\u2551   Praxis Cloud Authentication                     \u2551");
+  console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n");
+  const existingAuth = loadAuth();
+  if (existingAuth) {
+    console.log("\u26A0  Already authenticated");
+    console.log(`   User: ${existingAuth.userLogin}`);
+    console.log(
+      `   Authenticated at: ${new Date(existingAuth.authenticatedAt).toLocaleString()}
+`
+    );
+    console.log("Run 'praxis logout' to log out first.");
+    return;
+  }
+  let authResult;
+  if (options.token) {
+    console.log("\u{1F510} Using provided personal access token...");
+    try {
+      const response = await fetch("https://api.github.com/user", {
+        headers: {
+          Authorization: `Bearer ${options.token}`,
+          Accept: "application/vnd.github.v3+json"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Invalid token: ${response.statusText}`);
+      }
+      const userData = await response.json();
+      authResult = {
+        success: true,
+        token: options.token,
+        user: {
+          id: userData.id,
+          login: userData.login,
+          email: userData.email,
+          name: userData.name,
+          avatarUrl: userData.avatar_url
+        }
+      };
+    } catch (error) {
+      console.error("\n\u2717 Authentication failed");
+      console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  } else {
+    console.log("\u{1F510} Authenticating with GitHub device flow...");
+    authResult = await authenticateWithDeviceFlow(GITHUB_CLIENT_ID);
+  }
+  if (!authResult.success || !authResult.token || !authResult.user) {
+    console.error("\n\u2717 Authentication failed");
+    process.exit(1);
+  }
+  console.log(`\u2713 Authenticated as ${authResult.user.login}`);
+  console.log("\n\u{1F50D} Checking GitHub Sponsors status...");
+  try {
+    const sponsorsClient = createSponsorsClient(authResult.token);
+    const subscription = await sponsorsClient.getSubscription(authResult.user.login);
+    console.log(`\u2713 Subscription tier: ${subscription.tier}`);
+    console.log(`  Status: ${subscription.status}`);
+    console.log(`  Provider: ${subscription.provider}`);
+    if (subscription.tier === "free") {
+      console.log("\n\u{1F4A1} Upgrade to a paid tier for more features!");
+      console.log("   Visit: https://github.com/sponsors/plures");
+    }
+  } catch (error) {
+    console.warn("\n\u26A0  Could not check Sponsors status");
+    console.warn(`   Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const storedAuth = {
+    token: authResult.token,
+    userId: authResult.user.id,
+    userLogin: authResult.user.login,
+    userName: authResult.user.name,
+    userEmail: authResult.user.email,
+    authenticatedAt: Date.now()
+  };
+  saveAuth(storedAuth);
+  console.log("\n\u2713 Successfully logged in!");
+  console.log("\nNext steps:");
+  console.log("  \u2022 Use 'praxis cloud init' to set up cloud connection");
+  console.log("  \u2022 Use 'praxis whoami' to check your authentication");
+  console.log("  \u2022 Use 'praxis cloud status' to check subscription\n");
+}
+async function logoutCommand() {
+  const auth = loadAuth();
+  if (!auth) {
+    console.log("\n\u2717 Not currently logged in");
+    console.log("  Run 'praxis login' to authenticate\n");
+    return;
+  }
+  console.log(`
+Logging out user: ${auth.userLogin}...`);
+  deleteAuth();
+  console.log("\u2713 Successfully logged out\n");
+}
+async function whoamiCommand() {
+  const auth = loadAuth();
+  if (!auth) {
+    console.log("\n\u2717 Not currently logged in");
+    console.log("  Run 'praxis login' to authenticate\n");
+    process.exit(1);
+  }
+  console.log("\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.log("\u2551   Current Authentication                          \u2551");
+  console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n");
+  console.log(`User: ${auth.userLogin}`);
+  if (auth.userName) {
+    console.log(`Name: ${auth.userName}`);
+  }
+  if (auth.userEmail) {
+    console.log(`Email: ${auth.userEmail}`);
+  }
+  console.log(`User ID: ${auth.userId}`);
+  console.log(`Authenticated: ${new Date(auth.authenticatedAt).toLocaleString()}`);
+  console.log("\n\u{1F50D} Checking token validity...");
+  try {
+    const response = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${auth.token}`,
+        Accept: "application/vnd.github.v3+json"
+      }
+    });
+    if (response.ok) {
+      console.log("\u2713 Token is valid");
+      console.log("\n\u{1F50D} Checking subscription...");
+      const sponsorsClient = createSponsorsClient(auth.token);
+      const subscription = await sponsorsClient.getSubscription(auth.userLogin);
+      console.log(`Tier: ${subscription.tier}`);
+      console.log(`Status: ${subscription.status}`);
+      console.log(`Provider: ${subscription.provider}`);
+      console.log("\nLimits:");
+      console.log(`  Syncs/month: ${subscription.limits.maxSyncsPerMonth.toLocaleString()}`);
+      console.log(
+        `  Storage: ${(subscription.limits.maxStorageBytes / 1024 / 1024).toFixed(0)} MB`
+      );
+      console.log(`  Apps: ${subscription.limits.maxApps}`);
+      console.log(`  Team members: ${subscription.limits.maxTeamMembers ?? "Unlimited"}`);
+      console.log(`  Support: ${subscription.limits.supportLevel}`);
+    } else {
+      console.log("\u2717 Token is invalid or expired");
+      console.log("  Run 'praxis login' to re-authenticate");
+    }
+  } catch (error) {
+    console.error("\n\u2717 Failed to check token validity");
+    console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  console.log();
+}
+function getAuthToken() {
+  const auth = loadAuth();
+  return auth?.token || null;
+}
+export {
+  getAuthToken,
+  loginCommand,
+  logoutCommand,
+  whoamiCommand
+};