@notis_ai/cli 0.2.0-beta.137.1 → 0.2.0-beta.144.1

package/dist/scaffolds/notis-random/lib/notis-tools.ts

@@ -1,128 +0,0 @@
-'use client';
-
-import { useCallback, useEffect, useState } from 'react';
-import { useTool } from '@notis/sdk';
-import type { RollDocument } from '@/lib/roll-record';
-import type { Roll } from '@/lib/rng';
-import { formatNumber } from '@/lib/utils';
-
-type QueryRollsArgs = {
-  database_slug: 'rolls';
-  query?: {
-    page_size?: number;
-  };
-  offset?: number;
-};
-
-type QueryRollsResult = {
-  documents?: RollDocument[];
-  has_more?: boolean;
-  next_offset?: number | null;
-  message?: string;
-  error?: string;
-};
-
-type UpsertRollArgs = {
-  title: string;
-  Value: number;
-  Mode: Roll['mode'];
-  Min: number;
-  Max: number;
-  'Rolled At': string;
-};
-
-type UpsertRollResult = {
-  status?: string;
-  document?: RollDocument;
-  message?: string;
-  error?: string;
-};
-
-export function useRollDocuments(pageSize = 20, fetchAll = false) {
-  const queryRolls = useTool<QueryRollsArgs, QueryRollsResult>('LOCAL_NOTIS_DATABASE_QUERY');
-  const [documents, setDocuments] = useState<RollDocument[]>([]);
-  const [error, setError] = useState<Error | null>(null);
-  const [fetchKey, setFetchKey] = useState(0);
-
-  const refetch = useCallback(() => {
-    setFetchKey((key) => key + 1);
-  }, []);
-
-  useEffect(() => {
-    let cancelled = false;
-    setError(null);
-
-    const fetchRolls = async (): Promise<RollDocument[]> => {
-      const allDocuments: RollDocument[] = [];
-      let offset = 0;
-      while (true) {
-        const result = await queryRolls.call({
-          database_slug: 'rolls',
-          query: { page_size: pageSize },
-          ...(offset > 0 ? { offset } : {}),
-        });
-        const message = result.error ?? result.message;
-        if (message && !result.documents) {
-          throw new Error(message);
-        }
-        allDocuments.push(...(result.documents ?? []));
-        if (!fetchAll || !result.has_more) return allDocuments;
-        if (typeof result.next_offset !== 'number' || result.next_offset <= offset) {
-          throw new Error('Roll history returned an invalid pagination offset.');
-        }
-        offset = result.next_offset;
-      }
-    };
-
-    fetchRolls()
-      .then((result) => {
-        if (cancelled) return;
-        setDocuments(result);
-      })
-      .catch((err) => {
-        if (cancelled) return;
-        setError(err instanceof Error ? err : new Error(String(err)));
-        setDocuments([]);
-      });
-
-    return () => {
-      cancelled = true;
-    };
-  }, [fetchAll, fetchKey, pageSize, queryRolls.call]);
-
-  return {
-    documents,
-    loading: queryRolls.loading,
-    error: queryRolls.error ?? error,
-    refetch,
-  };
-}
-
-export function usePersistRoll() {
-  const upsertRoll = useTool<UpsertRollArgs, UpsertRollResult>('LOCAL_NOTIS_DATABASE_UPSERT_ROLLS');
-
-  const persist = useCallback(
-    async (roll: Roll) => {
-      const result = await upsertRoll.call({
-        title: formatNumber(roll.value),
-        Value: roll.value,
-        Mode: roll.mode,
-        Min: roll.min,
-        Max: roll.max,
-        'Rolled At': roll.at,
-      });
-      const message = result.error ?? result.message;
-      if (message && result.status === 'error') {
-        throw new Error(message);
-      }
-      return result.document ?? null;
-    },
-    [upsertRoll.call],
-  );
-
-  return {
-    persist,
-    loading: upsertRoll.loading,
-    error: upsertRoll.error,
-  };
-}

package/dist/scaffolds/notis-random/lib/rng.ts

@@ -1,202 +0,0 @@
-export type Mode = 'integer' | 'decimal' | 'dice';
-
-export interface Roll {
-  value: number;
-  mode: Mode;
-  min: number;
-  max: number;
-  at: string;
-}
-
-/** Standard polyhedral dice offered in dice mode. */
-export const DICE_SIDES = [4, 6, 8, 10, 12, 20] as const;
-export type DiceSides = (typeof DICE_SIDES)[number];
-export const DEFAULT_DICE_SIDES: DiceSides = 6;
-
-/** Largest span we accept for an integer draw (stays inside Number.MAX_SAFE_INTEGER). */
-export const MAX_INTEGER_SPAN = 2 ** 32;
-
-const UINT32_RANGE = 0x1_0000_0000; // 2 ** 32
-
-/** Convert an editable numeric draft without treating an empty field as zero. */
-export function parseBoundDraft(value: string): number {
-  return value.trim() === '' ? Number.NaN : Number(value);
-}
-
-function randomUint32(): number {
-  const array = new Uint32Array(1);
-  crypto.getRandomValues(array);
-  return array[0] ?? 0;
-}
-
-/**
- * Uniform float in [0, 1) — note the exclusive upper bound. Dividing by 2**32
- * (not 2**32 - 1) is what keeps 1.0 unreachable, so callers can safely scale
- * the result without ever landing one past the top of their range.
- */
-export function randomUnit(): number {
-  return randomUint32() / UINT32_RANGE;
-}
-
-/**
- * Uniform integer in [lo, hi], both inclusive.
- *
- * `Math.floor(randomUnit() * span)` alone is biased whenever `span` does not
- * divide 2**32 evenly: the first `2**32 % span` buckets would each get one
- * extra source value. We remove that by rejecting draws that fall in the
- * ragged tail of the uint32 space, which makes every bucket exactly the same
- * size. The expected number of retries is below 1 for any span we allow.
- */
-export function randomIntInclusive(lo: number, hi: number): number {
-  const low = Math.ceil(lo);
-  const high = Math.floor(hi);
-  if (!Number.isFinite(low) || !Number.isFinite(high) || high < low) {
-    throw new RangeError(`Invalid integer range [${lo}, ${hi}]`);
-  }
-  if (!Number.isSafeInteger(low) || !Number.isSafeInteger(high)) {
-    throw new RangeError(`Integer bounds must be safe integers: [${lo}, ${hi}]`);
-  }
-
-  const span = high - low + 1;
-  if (span <= 1) return low;
-  if (span > MAX_INTEGER_SPAN) {
-    throw new RangeError(`Integer range too wide: ${span} values`);
-  }
-  if (span === UINT32_RANGE) {
-    return low + randomUint32();
-  }
-
-  // Values at or above `limit` fall outside the last whole bucket; redraw them.
-  const limit = UINT32_RANGE - (UINT32_RANGE % span);
-  let draw = randomUint32();
-  while (draw >= limit) {
-    draw = randomUint32();
-  }
-  return low + (draw % span);
-}
-
-/** Uniform float in [lo, hi) — inclusive low, exclusive high. */
-export function randomFloat(lo: number, hi: number): number {
-  if (hi === lo) return lo;
-  const span = hi - lo;
-  if (!Number.isFinite(lo) || !Number.isFinite(hi) || !Number.isFinite(span) || span < 0) {
-    throw new RangeError(`Invalid decimal range [${lo}, ${hi}]`);
-  }
-  return lo + randomUnit() * span;
-}
-
-export type BoundsIssue =
-  | { code: 'min-not-a-number'; message: string }
-  | { code: 'max-not-a-number'; message: string }
-  | { code: 'min-not-finite'; message: string }
-  | { code: 'max-not-finite'; message: string }
-  | { code: 'min-not-below-max'; message: string }
-  | { code: 'empty-integer-range'; message: string }
-  | { code: 'range-too-wide'; message: string };
-
-export interface BoundsCheck {
-  ok: boolean;
-  issue: BoundsIssue | null;
-  /** Bounds actually used by `roll`, after integer snapping. Null when invalid. */
-  min: number | null;
-  max: number | null;
-}
-
-/**
- * Validates a min/max pair for a given mode and reports the bounds that would
- * actually be used. Integer and dice modes snap inward (ceil the low end, floor
- * the high end) so a range like [1.2, 4.8] draws from {2, 3, 4} rather than
- * producing fractional "integers".
- */
-export function checkBounds(min: number, max: number, mode: Mode): BoundsCheck {
-  const invalid = (issue: BoundsIssue): BoundsCheck => ({ ok: false, issue, min: null, max: null });
-
-  if (Number.isNaN(min)) {
-    return invalid({ code: 'min-not-a-number', message: 'Minimum must be a number.' });
-  }
-  if (Number.isNaN(max)) {
-    return invalid({ code: 'max-not-a-number', message: 'Maximum must be a number.' });
-  }
-  if (!Number.isFinite(min)) {
-    return invalid({ code: 'min-not-finite', message: 'Minimum must be finite.' });
-  }
-  if (!Number.isFinite(max)) {
-    return invalid({ code: 'max-not-finite', message: 'Maximum must be finite.' });
-  }
-  if (min >= max) {
-    return invalid({
-      code: 'min-not-below-max',
-      message: 'Minimum must be strictly lower than maximum.',
-    });
-  }
-
-  if (mode === 'decimal') {
-    if (!Number.isFinite(max - min)) {
-      return invalid({
-        code: 'range-too-wide',
-        message: 'Range is too wide for a decimal draw.',
-      });
-    }
-    return { ok: true, issue: null, min, max };
-  }
-
-  const low = Math.ceil(min);
-  const high = Math.floor(max);
-  if (high < low) {
-    return invalid({
-      code: 'empty-integer-range',
-      message: `No whole number sits between ${min} and ${max}.`,
-    });
-  }
-  if (!Number.isSafeInteger(low) || !Number.isSafeInteger(high)) {
-    return invalid({
-      code: 'range-too-wide',
-      message: 'Whole-number bounds must be safe integers.',
-    });
-  }
-  if (high - low + 1 > MAX_INTEGER_SPAN) {
-    return invalid({
-      code: 'range-too-wide',
-      message: 'Range is too wide for a whole-number draw.',
-    });
-  }
-  return { ok: true, issue: null, min: low, max: high };
-}
-
-/**
- * Draws one value.
- *
- * - `integer` / `dice`: uniform over the whole numbers in [min, max], both ends
- *   inclusive and equally likely.
- * - `decimal`: uniform over the continuous interval [min, max) — the low bound
- *   is reachable, the high bound is not.
- *
- * Throws a `RangeError` when the bounds are unusable; call `checkBounds` first
- * to surface the reason to the user.
- */
-export function roll(min: number, max: number, mode: Mode): Roll {
-  const check = checkBounds(min, max, mode);
-  if (!check.ok || check.min == null || check.max == null) {
-    throw new RangeError(check.issue?.message ?? 'Invalid range.');
-  }
-
-  const value =
-    mode === 'decimal'
-      ? randomFloat(check.min, check.max)
-      : randomIntInclusive(check.min, check.max);
-
-  return {
-    value,
-    mode,
-    min: check.min,
-    max: check.max,
-    at: new Date().toISOString(),
-  };
-}
-
-/** Human label for a mode, matching the `Mode` select options in the database. */
-export function modeLabel(mode: Mode): string {
-  if (mode === 'decimal') return 'Decimal';
-  if (mode === 'dice') return 'Dice';
-  return 'Integer';
-}

package/dist/scaffolds/notis-random/lib/roll-record.ts

@@ -1,189 +0,0 @@
-import type { Mode } from '@/lib/rng';
-
-export interface RollDocument {
-  id: string;
-  title?: string;
-  properties?: Record<string, unknown>;
-  createdAt?: string | null;
-  created_at?: string | null;
-  created_time?: string | null;
-  createdTime?: string | null;
-  lastEditedTime?: string | null;
-  last_edited_time?: string | null;
-  updated_at?: string | null;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === 'object' && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-/** Flattens a Notion-shaped rich_text / title array to plain text. */
-function flattenRichText(value: unknown): string {
-  if (typeof value === 'string') return value;
-  if (!Array.isArray(value)) return '';
-  return value
-    .map((item) => {
-      const record = asRecord(item);
-      const text = asRecord(record?.text);
-      if (typeof text?.content === 'string') return text.content;
-      if (typeof record?.plain_text === 'string') return record.plain_text;
-      return '';
-    })
-    .join('');
-}
-
-/**
- * Collapses a Notion-shaped property value (`{type: 'number', number: 42}`)
- * to the underlying primitive. The native database tools return this shape,
- * while fixtures and older rows may already be flat, so both are accepted and
- * anything unrecognised passes straight through.
- */
-export function unwrapProperty(value: unknown): unknown {
-  const record = asRecord(value);
-  if (!record) return value;
-
-  const type = typeof record.type === 'string' ? record.type : null;
-  if (!type) return value;
-
-  if (type === 'title') return flattenRichText(record.title);
-  if (type === 'rich_text') return flattenRichText(record.rich_text);
-  if (type === 'select' || type === 'status') {
-    const inner = asRecord(record[type]);
-    return typeof inner?.name === 'string' ? inner.name : (record[type] ?? null);
-  }
-  if (type === 'date') {
-    const inner = asRecord(record.date);
-    return typeof inner?.start === 'string' ? inner.start : (record.date ?? null);
-  }
-  if (type in record) return record[type];
-  return value;
-}
-
-function readString(value: unknown): string | null {
-  const unwrapped = unwrapProperty(value);
-  if (typeof unwrapped === 'string') {
-    const trimmed = unwrapped.trim();
-    return trimmed.length ? trimmed : null;
-  }
-  if (typeof unwrapped === 'number' || typeof unwrapped === 'boolean') {
-    return String(unwrapped);
-  }
-  const record = asRecord(unwrapped);
-  if (record) {
-    if (typeof record.name === 'string') return record.name;
-    if (typeof record.start === 'string') return record.start;
-  }
-  return null;
-}
-
-function readNumber(value: unknown): number | null {
-  const unwrapped = unwrapProperty(value);
-  if (typeof unwrapped === 'number' && Number.isFinite(unwrapped)) {
-    return unwrapped;
-  }
-  const stringValue = readString(unwrapped);
-  if (!stringValue) {
-    return null;
-  }
-  const parsed = Number(stringValue);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-
-function readMode(value: unknown): Mode {
-  const raw = readString(value)?.toLowerCase();
-  if (raw === 'integer' || raw === 'decimal' || raw === 'dice') {
-    return raw;
-  }
-  return 'integer';
-}
-
-function readTimestamp(doc: RollDocument): string {
-  return (
-    readString(doc.properties?.['Rolled At']) ||
-    doc.createdAt ||
-    doc.created_at ||
-    doc.created_time ||
-    doc.createdTime ||
-    doc.lastEditedTime ||
-    doc.last_edited_time ||
-    doc.updated_at ||
-    ''
-  );
-}
-
-function sortTimestamp(value: string): number {
-  if (!value) return 0;
-  const parsed = Date.parse(value);
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-
-export interface RollRecord {
-  id: string;
-  value: number;
-  mode: Mode;
-  min: number | null;
-  max: number | null;
-  at: string;
-}
-
-export function normalizeRollRecord(doc: RollDocument): RollRecord {
-  const value =
-    readNumber(doc.properties?.['Value']) ??
-    readNumber(doc.properties?.['Name']) ??
-    readNumber(doc.title) ??
-    0;
-
-  return {
-    id: doc.id,
-    value,
-    mode: readMode(doc.properties?.['Mode']),
-    min: readNumber(doc.properties?.['Min']),
-    max: readNumber(doc.properties?.['Max']),
-    at: readTimestamp(doc),
-  };
-}
-
-export function sortRollRecordsDesc(a: RollRecord, b: RollRecord): number {
-  return sortTimestamp(b.at) - sortTimestamp(a.at);
-}
-
-/** Merges optimistic local rolls with fetched rows, newest first, id-deduped. */
-export function mergeRollRecords(...groups: RollRecord[][]): RollRecord[] {
-  const byId = new Map<string, RollRecord>();
-  for (const group of groups) {
-    for (const record of group) {
-      if (!byId.has(record.id)) {
-        byId.set(record.id, record);
-      }
-    }
-  }
-  return Array.from(byId.values()).sort(sortRollRecordsDesc);
-}
-
-export interface RollStats {
-  count: number;
-  lowest: number;
-  highest: number;
-  average: number;
-}
-
-/** Summary of a set of rolls. Returns null for an empty set. */
-export function summarizeRolls(records: RollRecord[]): RollStats | null {
-  if (records.length === 0) return null;
-  let lowest = Number.POSITIVE_INFINITY;
-  let highest = Number.NEGATIVE_INFINITY;
-  let total = 0;
-  for (const record of records) {
-    if (record.value < lowest) lowest = record.value;
-    if (record.value > highest) highest = record.value;
-    total += record.value;
-  }
-  return {
-    count: records.length,
-    lowest,
-    highest,
-    average: total / records.length,
-  };
-}

package/dist/scaffolds/notis-random/lib/utils.ts

@@ -1,25 +0,0 @@
-import { clsx, type ClassValue } from 'clsx';
-import { twMerge } from 'tailwind-merge';
-
-export function cn(...inputs: ClassValue[]): string {
-  return twMerge(clsx(inputs));
-}
-
-export function formatNumber(value: number): string {
-  if (Number.isInteger(value)) return value.toString();
-  return value.toFixed(4).replace(/0+$/, '').replace(/\.$/, '');
-}
-
-export function relativeTime(iso: string | null | undefined): string {
-  if (!iso) return '';
-  const then = new Date(iso).getTime();
-  if (Number.isNaN(then)) return '';
-  const diffSeconds = Math.round((Date.now() - then) / 1000);
-  if (diffSeconds < 5) return 'just now';
-  if (diffSeconds < 60) return `${diffSeconds}s ago`;
-  const diffMinutes = Math.round(diffSeconds / 60);
-  if (diffMinutes < 60) return `${diffMinutes}m ago`;
-  const diffHours = Math.round(diffMinutes / 60);
-  if (diffHours < 24) return `${diffHours}h ago`;
-  return new Date(iso).toLocaleDateString();
-}