@notis_ai/cli 0.2.7 → 0.2.8

package/dist/scaffolds/notis-random/components/ui/button.tsx

@@ -0,0 +1,50 @@
+import * as React from 'react';
+import { Slot } from '@radix-ui/react-slot';
+import { cva, type VariantProps } from 'class-variance-authority';
+
+import { cn } from '@/lib/utils';
+
+const buttonVariants = cva(
+  'inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50',
+  {
+    variants: {
+      variant: {
+        default: 'bg-foreground text-background hover:bg-foreground/90',
+        outline: 'border border-input bg-background hover:bg-accent hover:text-accent-foreground',
+        ghost: 'hover:bg-accent hover:text-accent-foreground',
+      },
+      size: {
+        default: 'h-10 px-4 py-2',
+        sm: 'h-9 rounded-md px-3',
+        lg: 'h-11 rounded-md px-8',
+        icon: 'h-10 w-10',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+      size: 'default',
+    },
+  },
+);
+
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  asChild?: boolean;
+}
+
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : 'button';
+    return (
+      <Comp
+        className={cn(buttonVariants({ variant, size, className }))}
+        ref={ref}
+        {...props}
+      />
+    );
+  },
+);
+Button.displayName = 'Button';
+
+export { Button, buttonVariants };

package/dist/scaffolds/notis-random/components/ui/card.tsx

@@ -0,0 +1,16 @@
+import * as React from 'react';
+
+import { cn } from '@/lib/utils';
+
+const Card = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+  ({ className, ...props }, ref) => (
+    <div
+      ref={ref}
+      className={cn('rounded-xl border border-border bg-card text-card-foreground', className)}
+      {...props}
+    />
+  ),
+);
+Card.displayName = 'Card';
+
+export { Card };

package/dist/scaffolds/notis-random/components/ui/input.tsx

@@ -0,0 +1,23 @@
+import * as React from 'react';
+
+import { cn } from '@/lib/utils';
+
+const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<'input'>>(
+  ({ className, type, ...props }, ref) => (
+    <input
+      type={type}
+      className={cn(
+        'flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm text-foreground ring-offset-background',
+        'file:border-0 file:bg-transparent file:text-sm file:font-medium',
+        'placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+        'disabled:cursor-not-allowed disabled:opacity-50',
+        className,
+      )}
+      ref={ref}
+      {...props}
+    />
+  ),
+);
+Input.displayName = 'Input';
+
+export { Input };

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

@@ -16,6 +16,8 @@ type QueryRollsArgs = {
 
 type QueryRollsResult = {
   documents?: RollDocument[];
+  has_more?: boolean;
+  next_offset?: number | null;
   message?: string;
   error?: string;
 };
@@ -36,7 +38,7 @@ type UpsertRollResult = {
   error?: string;
 };
 
-export function useRollDocuments(pageSize?: number) {
+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);
@@ -50,15 +52,32 @@ export function useRollDocuments(pageSize?: number) {
     let cancelled = false;
     setError(null);
 
-    queryRolls
-      .call({ database_slug: 'rolls', query: { page_size: pageSize } })
-      .then((result) => {
-        if (cancelled) return;
+    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);
         }
-        setDocuments(result.documents ?? []);
+        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;
@@ -69,7 +88,7 @@ export function useRollDocuments(pageSize?: number) {
     return () => {
       cancelled = true;
     };
-  }, [fetchKey, pageSize, queryRolls.call]);
+  }, [fetchAll, fetchKey, pageSize, queryRolls.call]);
 
   return {
     documents,

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

@@ -8,35 +8,195 @@ export interface Roll {
   at: string;
 }
 
-function cryptoRandom(): number {
+/** 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) / 0xffffffff;
+  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 lo = Math.min(min, max);
-  const hi = Math.max(min, max);
-  let value: number;
-  if (mode === 'integer' || mode === 'dice') {
-    value = Math.floor(cryptoRandom() * (hi - lo + 1)) + lo;
-  } else {
-    value = cryptoRandom() * (hi - lo) + lo;
+  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: lo,
-    max: hi,
+    min: check.min,
+    max: check.max,
     at: new Date().toISOString(),
   };
 }
 
-export const DICE_FACES: Record<number, string> = {
-  1: 'dice-1',
-  2: 'dice-2',
-  3: 'dice-3',
-  4: 'dice-4',
-  5: 'dice-5',
-  6: 'dice-6',
-};
+/** 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

@@ -2,41 +2,88 @@ import type { Mode } from '@/lib/rng';
 
 export interface RollDocument {
   id: string;
-  title: 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 {
-  if (typeof value === 'string') {
-    const trimmed = value.trim();
+  const unwrapped = unwrapProperty(value);
+  if (typeof unwrapped === 'string') {
+    const trimmed = unwrapped.trim();
     return trimmed.length ? trimmed : null;
   }
-  if (typeof value === 'number' || typeof value === 'boolean') {
-    return String(value);
+  if (typeof unwrapped === 'number' || typeof unwrapped === 'boolean') {
+    return String(unwrapped);
   }
-  if (value && typeof value === 'object') {
-    const record = value as Record<string, unknown>;
-    if (typeof record.name === 'string') {
-      return record.name;
-    }
-    if (typeof record.start === 'string') {
-      return record.start;
-    }
+  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 {
-  if (typeof value === 'number' && Number.isFinite(value)) {
-    return value;
+  const unwrapped = unwrapProperty(value);
+  if (typeof unwrapped === 'number' && Number.isFinite(unwrapped)) {
+    return unwrapped;
   }
-  const stringValue = readString(value);
+  const stringValue = readString(unwrapped);
   if (!stringValue) {
     return null;
   }
@@ -58,6 +105,7 @@ function readTimestamp(doc: RollDocument): string {
     doc.createdAt ||
     doc.created_at ||
     doc.created_time ||
+    doc.createdTime ||
     doc.lastEditedTime ||
     doc.last_edited_time ||
     doc.updated_at ||
@@ -100,3 +148,42 @@ export function normalizeRollRecord(doc: RollDocument): RollRecord {
 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,
+  };
+}