@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/telemetry/trigger.ts

@@ -1,107 +0,0 @@
-/**
- * Opportunistic analysis trigger — the `git gc --auto` model. Each CLI start
- * cheaply scans for a closed, unanalyzed session and spawns ONE detached
- * analyzer for it. No daemon, no cron; a lockfile keeps it single-flight.
- * The same scan pays for the age sweep (see retention.ts), which is why the
- * store stays bounded without anything resembling a background job.
- */
-import { spawn } from 'node:child_process'
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { MAX_REMOVALS_ON_START, sweepByAge } from './retention'
-import { telemetryEnabled } from './settings'
-import { scanSessions, sessionsRoot, type SessionScan } from './store'
-
-const LOCK_STALE_MS = 30 * 60 * 1000
-
-function lockPath(): string {
-  return join(sessionsRoot(), '.analyzer.lock')
-}
-
-/** True when the lock is free (or stale/dead) and was claimed. */
-function claimLock(): boolean {
-  const path = lockPath()
-  try {
-    if (existsSync(path)) {
-      const lock = JSON.parse(readFileSync(path, 'utf-8')) as { pid: number; at: number }
-      const stale = Date.now() - lock.at > LOCK_STALE_MS
-      let alive = false
-      try {
-        process.kill(lock.pid, 0)
-        alive = true
-      } catch {
-        /* dead */
-      }
-      if (alive && !stale) return false
-      unlinkSync(path)
-    }
-    mkdirSync(sessionsRoot(), { recursive: true })
-    writeFileSync(path, JSON.stringify({ pid: process.pid, at: Date.now() }))
-    return true
-  } catch {
-    return false
-  }
-}
-
-/** Release only in the parent that claimed; the child rewrites its own. */
-export function releaseLock(): void {
-  try {
-    unlinkSync(lockPath())
-  } catch {
-    /* already gone */
-  }
-}
-
-/**
- * Fire-and-forget: spawn a detached `astrale session analyze <id> --auto` for
- * the most recently closed unanalyzed session, if any. Never throws, never
- * blocks — worst case a few ms of directory stats.
- */
-export function maybeTriggerAnalysis(argv: string[], scan?: readonly SessionScan[]): void {
-  try {
-    if (process.env.ASTRALE_TELEMETRY_NO_TRIGGER === '1') return
-
-    const sessions = scan ?? scanSessions()
-    // Retention runs ahead of the kill-switch check and on `session` commands
-    // too — turning telemetry off must still drain what is already on disk.
-    const swept = new Set(sweepByAge(sessions, { limit: MAX_REMOVALS_ON_START }).removed)
-
-    if (!telemetryEnabled()) return
-    // Never cascade off the session commands themselves.
-    if (argv[2] === 'session') return
-
-    const target = sessions.find(
-      (s) => s.closed && !s.analyzed && s.lastEventAt !== null && !swept.has(s.id),
-    )
-    if (!target) return
-    if (!claimLock()) return
-
-    // Re-invoke self: execPath is bun/node (dev) or the compiled binary; when
-    // argv[1] is a real script path, keep it as the first argument. In a
-    // bun-compiled binary argv[1] is a virtual /$bunfs/ path that must NOT be
-    // passed — the binary re-runs itself from execPath alone.
-    const script = process.argv[1]
-    const args =
-      script && script !== process.execPath && !script.startsWith('/$bunfs') ? [script] : []
-    args.push('session', 'analyze', target.id, '--auto')
-    const child = spawn(process.execPath, args, {
-      detached: true,
-      stdio: 'ignore',
-      env: { ...process.env, ASTRALE_TELEMETRY_NO_TRIGGER: '1' },
-    })
-    child.unref()
-    // The lock hands over to the child: it re-stamps with its own pid on start.
-  } catch {
-    /* telemetry must never affect the CLI */
-  }
-}
-
-/** Called by `session analyze --auto` to take over the parent's claim. */
-export function restampLock(): void {
-  try {
-    writeFileSync(lockPath(), JSON.stringify({ pid: process.pid, at: Date.now() }))
-  } catch {
-    /* best effort */
-  }
-}

package/src/telemetry/types.ts

@@ -1,64 +0,0 @@
-/**
- * Telemetry contracts. One CLI invocation = one appended event; one session =
- * one directory of evidence under `~/.astrale/sessions/`; harness adapters
- * contribute transcript discovery + a reading guide, never normalization.
- */
-
-/** One CLI invocation, one JSON line in events.jsonl. */
-export type TelemetryEvent = {
-  /** Envelope version. */
-  v: 1
-  /** ISO timestamp at process start. */
-  ts: string
-  /** argv after the binary name, secrets redacted (see redact.ts). */
-  argv: string[]
-  exitCode: number
-  durationMs: number
-  /** Error class name when the command threw (AstraleError code preferred). */
-  errorName?: string
-  cwd: string
-  /** Workspace root the session is bucketed by (git root, else cwd). */
-  root: string
-  /** Which surface produced the event. */
-  surface: 'cli'
-}
-
-/** Written once when a session directory is created. */
-export type SessionMeta = {
-  id: string
-  root: string
-  /** true when the id came from ASTRALE_SESSION (a surface owns the lifecycle). */
-  explicit: boolean
-  createdAt: string
-}
-
-/** Written by the analyzer when it finishes with a session (any outcome). */
-export type AnalyzedMarker = {
-  analyzedAt: string
-  outcome: 'skipped-quiet' | 'reported' | 'filed' | 'error'
-  note?: string
-}
-
-/** An agent-harness session discovered on this machine (transcript = evidence). */
-export type HarnessSession = {
-  harness: string
-  sessionId?: string
-  transcriptPath: string
-  cwd?: string
-  startedAt?: string
-  endedAt?: string
-  sizeBytes: number
-}
-
-/** Deterministic signals extracted from events.jsonl — the free gate's input. */
-export type SessionSignals = {
-  eventCount: number
-  /** Events with a non-zero exit, grouped by leading command tokens. */
-  failures: { command: string; count: number; errorNames: string[] }[]
-  /** Same leading command tokens re-run 3+ times (retry smell). */
-  retries: { command: string; count: number }[]
-  firstEventAt?: string
-  lastEventAt?: string
-  /** Harness transcripts overlapping this session's root + time window. */
-  harnessSessions: HarnessSession[]
-}

package/src/test-utils.ts

@@ -1,18 +0,0 @@
-import { mkdtemp, mkdir } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { createPaths, type Paths } from './state/index'
-
-export type TestEnv = {
-  paths: Paths
-  tmp: string
-}
-
-export async function createTestEnv(): Promise<TestEnv> {
-  const tmp = await mkdtemp(join(tmpdir(), 'astrale-test-'))
-  const paths = createPaths(tmp)
-  await mkdir(paths.keys, { recursive: true })
-  await mkdir(paths.data, { recursive: true })
-  return { paths, tmp }
-}

package/src/ui/.spec/api.d.ts

@@ -1,14 +0,0 @@
-export {
-  addUi,
-  applyPreset,
-  diffUi,
-  doctorUi,
-  initUi,
-  listUi,
-  viewUi,
-  type InitUiOptions,
-} from '../operations.js'
-export { UI_PRESETS, UiError, type UiLock, type UiPreset } from '../model.js'
-export { discoverUiProject, type UiProject } from '../project.js'
-export { resolveUiRelease } from '../release.js'
-export { shadcnInvocation, type UiRunner } from '../runner.js'

package/src/ui/.spec/architecture.md

@@ -1,14 +0,0 @@
-# UI local tooling
-
-This private CLI owner manages an existing local React project. It does not connect to a Kernel and
-does not add React, Base UI, Tailwind, shadcn, or the UI runtime to the installed CLI dependency
-graph.
-
-One registry operation resolves one immutable UI commit. During the V1 prerelease, operations
-without an explicit version resolve the npm `beta` dist-tag; the legacy `latest` channel is not a V1
-source. Package compatibility and registry reads use that commit. Patterns and blocks invoke the
-release-qualified shadcn CLI on demand through the detected package manager. Released themes copy
-the exact admitted embedded CSS directly, while a local playground export is admitted and copied
-without registry or shadcn. Both theme paths install consumer-owned source and activate it through
-one project-relative CSS import, and complete application writes before the lock advances. Dry-run,
-list, and doctor do not claim a file mutation.

package/src/ui/.spec/laws.ts

@@ -1,50 +0,0 @@
-import { defineLaw } from '@astrale-os/spec/authoring'
-
-export const CLI_UI_BETA_DEFAULT = defineLaw({
-  id: 'CLI-UI-BETA-DEFAULT',
-  statement:
-    'Until the UI V1 channel is promoted, an operation without an explicit version resolves the npm beta dist-tag and never the legacy latest dist-tag.',
-  tests: [{ file: '../__tests__/ui.test.ts', id: 'TEST-CLI-UI-BETA-DEFAULT' }],
-})
-
-export const CLI_UI_ONE_SNAPSHOT = defineLaw({
-  id: 'CLI-UI-ONE-SNAPSHOT',
-  statement:
-    'Each UI operation resolves one immutable repository commit and reads compatibility, registry, and item source only from that snapshot.',
-  tests: [{ file: '../__tests__/ui.test.ts', id: 'TEST-CLI-UI-ONE-SNAPSHOT' }],
-})
-
-export const CLI_UI_LOCK_AFTER_SUCCESS = defineLaw({
-  id: 'CLI-UI-LOCK-AFTER-SUCCESS',
-  statement:
-    'Dry runs and failed package or source operations do not advance astrale-ui.lock.json.',
-  tests: [{ file: '../__tests__/ui.test.ts', id: 'TEST-CLI-UI-LOCK-AFTER-SUCCESS' }],
-})
-
-export const CLI_UI_BOUNDED_REMOTE_DOCUMENTS = defineLaw({
-  id: 'CLI-UI-BOUNDED-REMOTE-DOCUMENTS',
-  statement:
-    'Release metadata and registry documents are size-bounded, include-bounded, and normalized to stable UI registry errors before any project mutation.',
-  tests: [{ file: '../__tests__/ui.test.ts', id: 'TEST-CLI-UI-BOUNDED-REMOTE-DOCUMENTS' }],
-})
-
-export const CLI_UI_EXACT_ITEM_SOURCE = defineLaw({
-  id: 'CLI-UI-EXACT-ITEM-SOURCE',
-  statement:
-    'An add operation admits the exact built item document against the release index and records its content-bearing source digest before any consumer mutation; only patterns and blocks invoke project tooling.',
-  tests: [{ file: '../__tests__/ui.test.ts', id: 'TEST-CLI-UI-EXACT-ITEM-SOURCE' }],
-})
-
-export const CLI_UI_THEME_OWNERSHIP = defineLaw({
-  id: 'CLI-UI-THEME-OWNERSHIP',
-  statement:
-    'A released or locally exported theme becomes one project-contained consumer-owned CSS file, is activated by one relative host stylesheet import, and rolls back file, import, and lock together on failure.',
-  tests: [{ file: '../__tests__/ui.test.ts', id: 'TEST-CLI-UI-THEME-OWNERSHIP' }],
-})
-
-export const CLI_UI_SEMANTIC_DIFF = defineLaw({
-  id: 'CLI-UI-SEMANTIC-DIFF',
-  statement:
-    'Diff is read-only, path-contained, and classifies locked source and files as upstream changed, unchanged, modified, or deleted without delegating truth to tool output.',
-  tests: [{ file: '../__tests__/ui.test.ts', id: 'TEST-CLI-UI-SEMANTIC-DIFF' }],
-})

package/src/ui/.spec/layout.ts

@@ -1,16 +0,0 @@
-import { defineLayout } from '@astrale-os/spec/authoring'
-
-export default defineLayout({
-  entries: [
-    '.spec/',
-    '__tests__/',
-    'index.ts',
-    'lock.ts',
-    'model.ts',
-    'operations.ts',
-    'project.ts',
-    'release.ts',
-    'runner.ts',
-  ],
-  exact: true,
-})