@aemonge-dev/pi-stardeck 0.0.0-stage → 0.6.0

package/packages/status/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "status",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Project status producer for the pi-stardeck deck",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "status",
+    "footer"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}\" --ignore-path .prettierignore",
+    "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}\" --ignore-path .prettierignore",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test --experimental-strip-types test/*.test.ts",
+    "check": "npm run format:check && npm run typecheck && npm test"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  }
+}

package/packages/status/src/active-work.ts

@@ -0,0 +1,235 @@
+import { basename } from 'node:path';
+import type { GoalHeaderState } from './goal.ts';
+
+export const OPEN_SPEC_FOCUS_ENTRY_TYPE = 'galactica-status.openspec-focus.v1';
+export const SESSION_WORK_FOCUS_ENTRY_TYPE = 'galactica-status.session-work.v1';
+export const SESSION_SUBJECT_ENTRY_TYPE = 'galactica-status.session-subject.v1';
+
+export type TaskOpenSpecFocus = {
+  mode: 'task';
+  change: string;
+  taskId: string;
+};
+
+export type OpenSpecFocus = { mode: 'none' } | TaskOpenSpecFocus;
+
+export const NO_OPEN_SPEC_FOCUS: OpenSpecFocus = { mode: 'none' };
+
+export type SessionWorkFocus =
+  { state: 'clear' } | { state: 'active' | 'validation'; intent: string };
+
+export const NO_SESSION_WORK_FOCUS: SessionWorkFocus = { state: 'clear' };
+
+export type SessionSubject = { state: 'clear' } | { state: 'set'; title: string };
+
+export const NO_SESSION_SUBJECT: SessionSubject = { state: 'clear' };
+
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/gu;
+const MAX_TITLE_POINTS = 180;
+const MAX_TASK_TITLE_POINTS = 72;
+const MAX_WORK_INTENT_POINTS = 160;
+const MAX_SUBJECT_POINTS = 120;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function shorten(value: string, maximum: number): string {
+  const points = Array.from(value);
+  if (points.length <= maximum) return value;
+  return `${points.slice(0, Math.max(1, maximum - 1)).join('')}…`;
+}
+
+export function normalizeTitlePart(value: string): string {
+  return value.replace(CONTROL_CHARACTERS, ' ').replace(/\s+/gu, ' ').trim();
+}
+
+function explicitId(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const normalized = normalizeTitlePart(value);
+  return normalized || undefined;
+}
+
+export function taskFocus(
+  change: unknown,
+  taskId: unknown,
+): TaskOpenSpecFocus | undefined {
+  const normalizedChange = explicitId(change);
+  const normalizedTaskId = explicitId(taskId);
+  if (!normalizedChange || !normalizedTaskId) return undefined;
+  return { mode: 'task', change: normalizedChange, taskId: normalizedTaskId };
+}
+
+export function parseOpenSpecFocus(value: unknown): OpenSpecFocus | undefined {
+  if (!isRecord(value)) return undefined;
+  if (value.mode === 'none') return NO_OPEN_SPEC_FOCUS;
+  if (value.mode !== 'task') return undefined;
+  return taskFocus(value.change, value.taskId);
+}
+
+export function sessionWorkFocus(
+  state: unknown,
+  intent?: unknown,
+): SessionWorkFocus | undefined {
+  if (state === 'clear') return NO_SESSION_WORK_FOCUS;
+  if (state !== 'active' && state !== 'validation') return undefined;
+  const normalizedIntent = explicitId(intent);
+  if (!normalizedIntent) return undefined;
+  return {
+    state,
+    intent: shorten(normalizedIntent, MAX_WORK_INTENT_POINTS),
+  };
+}
+
+export function parseSessionWorkFocus(value: unknown): SessionWorkFocus | undefined {
+  if (!isRecord(value)) return undefined;
+  return sessionWorkFocus(value.state, value.intent);
+}
+
+export function sessionSubject(
+  state: unknown,
+  title?: unknown,
+): SessionSubject | undefined {
+  if (state === 'clear') return NO_SESSION_SUBJECT;
+  if (state !== 'set') return undefined;
+  const normalizedTitle = explicitId(title);
+  if (!normalizedTitle) return undefined;
+  return {
+    state,
+    title: shorten(normalizedTitle, MAX_SUBJECT_POINTS),
+  };
+}
+
+export function parseSessionSubject(value: unknown): SessionSubject | undefined {
+  if (!isRecord(value)) return undefined;
+  return sessionSubject(value.state, value.title);
+}
+
+export function restoreOpenSpecFocus(entries: readonly unknown[]): OpenSpecFocus {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (
+      !isRecord(entry) ||
+      entry.type !== 'custom' ||
+      entry.customType !== OPEN_SPEC_FOCUS_ENTRY_TYPE
+    ) {
+      continue;
+    }
+    const focus = parseOpenSpecFocus(entry.data);
+    if (focus) return focus;
+  }
+  return NO_OPEN_SPEC_FOCUS;
+}
+
+export function restoreSessionWorkFocus(entries: readonly unknown[]): SessionWorkFocus {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (
+      !isRecord(entry) ||
+      entry.type !== 'custom' ||
+      entry.customType !== SESSION_WORK_FOCUS_ENTRY_TYPE
+    ) {
+      continue;
+    }
+    const focus = parseSessionWorkFocus(entry.data);
+    if (focus) return focus;
+  }
+  return NO_SESSION_WORK_FOCUS;
+}
+
+export function restoreSessionSubject(entries: readonly unknown[]): SessionSubject {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (
+      !isRecord(entry) ||
+      entry.type !== 'custom' ||
+      entry.customType !== SESSION_SUBJECT_ENTRY_TYPE
+    ) {
+      continue;
+    }
+    const subject = parseSessionSubject(entry.data);
+    if (subject) return subject;
+  }
+  return NO_SESSION_SUBJECT;
+}
+
+export function taskflowRunFocus(input: unknown): TaskOpenSpecFocus | undefined {
+  if (!isRecord(input) || input.action !== 'run' || !isRecord(input.args)) {
+    return undefined;
+  }
+  const focus = taskFocus(input.args.change, input.args.task);
+  return focus && focus.change !== 'none' && focus.taskId !== 'none'
+    ? focus
+    : undefined;
+}
+
+export function sameOpenSpecFocus(left: OpenSpecFocus, right: OpenSpecFocus): boolean {
+  if (left.mode !== right.mode) return false;
+  return (
+    left.mode === 'none' ||
+    (right.mode === 'task' &&
+      left.change === right.change &&
+      left.taskId === right.taskId)
+  );
+}
+
+export function sameSessionWorkFocus(
+  left: SessionWorkFocus,
+  right: SessionWorkFocus,
+): boolean {
+  if (left.state !== right.state) return false;
+  return (
+    left.state === 'clear' || (right.state !== 'clear' && left.intent === right.intent)
+  );
+}
+
+export function sameSessionSubject(
+  left: SessionSubject,
+  right: SessionSubject,
+): boolean {
+  if (left.state !== right.state) return false;
+  return (
+    left.state === 'clear' || (right.state === 'set' && left.title === right.title)
+  );
+}
+
+export function formatActiveWorkTitle(options: {
+  focus: OpenSpecFocus;
+  workFocus?: SessionWorkFocus;
+  goal?: GoalHeaderState | null;
+  subject?: SessionSubject;
+  taskTitle?: string;
+  sessionName?: string;
+  projectRoot?: string;
+  cwd: string;
+}): string {
+  let detail: string;
+  if (options.focus.mode === 'task') {
+    const taskTitle = options.taskTitle
+      ? shorten(normalizeTitlePart(options.taskTitle), MAX_TASK_TITLE_POINTS)
+      : '';
+    detail = `${options.focus.change} › ${options.focus.taskId}${taskTitle ? ` ${taskTitle}` : ''}`;
+  } else if (options.goal) {
+    detail =
+      options.goal.status === 'complete'
+        ? 'Validate › Goal'
+        : options.goal.status === 'active' && !options.goal.waiting
+          ? 'Goal'
+          : `Goal › ${options.goal.waiting ? 'waiting' : options.goal.status.replace('_', ' ')}`;
+  } else if (options.workFocus && options.workFocus.state !== 'clear') {
+    detail =
+      options.workFocus.state === 'validation'
+        ? `Validate › ${options.workFocus.intent}`
+        : options.workFocus.intent;
+  } else if (options.subject && options.subject.state === 'set') {
+    detail = options.subject.title;
+  } else {
+    detail =
+      normalizeTitlePart(options.sessionName ?? '') ||
+      normalizeTitlePart(basename(options.projectRoot ?? '')) ||
+      normalizeTitlePart(basename(options.cwd)) ||
+      'pi';
+  }
+
+  return shorten(`π  ${normalizeTitlePart(detail)}`, MAX_TITLE_POINTS);
+}

package/packages/status/src/config.ts

@@ -0,0 +1,218 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import type { CommandSpec, GalacticaStatusConfig, LoadedConfig } from './types.ts';
+
+const MIN_INTERVAL_SECONDS = 60;
+const MAX_INTERVAL_SECONDS = 86_400;
+const MIN_TIMEOUT_SECONDS = 1;
+const MAX_TIMEOUT_SECONDS = 120;
+
+export const DEFAULT_CONFIG: GalacticaStatusConfig = {
+  version: 1,
+  enabled: true,
+  openspec: {
+    enabled: true,
+    change: null,
+  },
+  diagnostics: {
+    enabled: true,
+    sourceFile: null,
+    command: null,
+    intervalSeconds: 300,
+    runAutomatically: false,
+    timeoutSeconds: 15,
+  },
+  orchestration: {
+    enabled: true,
+    stateFile: null,
+  },
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function booleanValue(value: unknown, fallback: boolean): boolean {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+function nullableString(value: unknown, fallback: string | null): string | null {
+  if (value === null) return null;
+  return typeof value === 'string' && value.trim() ? value.trim() : fallback;
+}
+
+function boundedInteger(
+  value: unknown,
+  fallback: number,
+  minimum: number,
+  maximum: number,
+): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
+  return Math.max(minimum, Math.min(maximum, Math.trunc(value)));
+}
+
+function parseCommand(value: unknown, warnings: string[]): CommandSpec | null {
+  if (value === null || value === undefined) return null;
+
+  if (Array.isArray(value)) {
+    if (
+      value.length > 0 &&
+      value.every((part) => typeof part === 'string' && part.length > 0)
+    ) {
+      return {
+        executable: value[0] as string,
+        args: value.slice(1) as string[],
+      };
+    }
+    warnings.push('diagnostics.command array was ignored because it is invalid');
+    return null;
+  }
+
+  if (isRecord(value)) {
+    const executable = value.executable;
+    const args = value.args;
+    if (
+      typeof executable === 'string' &&
+      executable.length > 0 &&
+      (args === undefined ||
+        (Array.isArray(args) && args.every((part) => typeof part === 'string')))
+    ) {
+      return { executable, args: (args ?? []) as string[] };
+    }
+  }
+
+  warnings.push(
+    'diagnostics.command was ignored; use null, an argv array, or { executable, args }',
+  );
+  return null;
+}
+
+function unknownKeys(
+  value: Record<string, unknown>,
+  allowed: readonly string[],
+  path: string,
+  warnings: string[],
+): void {
+  for (const key of Object.keys(value)) {
+    if (!allowed.includes(key)) warnings.push(`${path}.${key} was ignored`);
+  }
+}
+
+export function parseConfig(value: unknown): {
+  config: GalacticaStatusConfig;
+  warnings: string[];
+} {
+  const warnings: string[] = [];
+  if (!isRecord(value)) {
+    return {
+      config: structuredClone(DEFAULT_CONFIG),
+      warnings: ['configuration root is not an object; defaults are active'],
+    };
+  }
+
+  unknownKeys(
+    value,
+    ['version', 'enabled', 'openspec', 'diagnostics', 'orchestration'],
+    'config',
+    warnings,
+  );
+
+  if (value.version !== undefined && value.version !== 1) {
+    warnings.push('unsupported config version; version 1 defaults are active');
+  }
+
+  const openspec = isRecord(value.openspec) ? value.openspec : {};
+  const diagnostics = isRecord(value.diagnostics) ? value.diagnostics : {};
+  const orchestration = isRecord(value.orchestration) ? value.orchestration : {};
+
+  unknownKeys(openspec, ['enabled', 'change'], 'openspec', warnings);
+  unknownKeys(
+    diagnostics,
+    [
+      'enabled',
+      'sourceFile',
+      'command',
+      'intervalSeconds',
+      'runAutomatically',
+      'timeoutSeconds',
+    ],
+    'diagnostics',
+    warnings,
+  );
+  unknownKeys(orchestration, ['enabled', 'stateFile'], 'orchestration', warnings);
+
+  return {
+    config: {
+      version: 1,
+      enabled: booleanValue(value.enabled, DEFAULT_CONFIG.enabled),
+      openspec: {
+        enabled: booleanValue(openspec.enabled, DEFAULT_CONFIG.openspec.enabled),
+        change: nullableString(openspec.change, DEFAULT_CONFIG.openspec.change),
+      },
+      diagnostics: {
+        enabled: booleanValue(diagnostics.enabled, DEFAULT_CONFIG.diagnostics.enabled),
+        sourceFile: nullableString(
+          diagnostics.sourceFile,
+          DEFAULT_CONFIG.diagnostics.sourceFile,
+        ),
+        command: parseCommand(diagnostics.command, warnings),
+        intervalSeconds: boundedInteger(
+          diagnostics.intervalSeconds,
+          DEFAULT_CONFIG.diagnostics.intervalSeconds,
+          MIN_INTERVAL_SECONDS,
+          MAX_INTERVAL_SECONDS,
+        ),
+        runAutomatically: booleanValue(
+          diagnostics.runAutomatically,
+          DEFAULT_CONFIG.diagnostics.runAutomatically,
+        ),
+        timeoutSeconds: boundedInteger(
+          diagnostics.timeoutSeconds,
+          DEFAULT_CONFIG.diagnostics.timeoutSeconds,
+          MIN_TIMEOUT_SECONDS,
+          MAX_TIMEOUT_SECONDS,
+        ),
+      },
+      orchestration: {
+        enabled: booleanValue(
+          orchestration.enabled,
+          DEFAULT_CONFIG.orchestration.enabled,
+        ),
+        stateFile: nullableString(
+          orchestration.stateFile,
+          DEFAULT_CONFIG.orchestration.stateFile,
+        ),
+      },
+    },
+    warnings,
+  };
+}
+
+export function getConfigPath(): string {
+  const agentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
+  return join(agentDir, 'galactica-status.json');
+}
+
+export async function loadConfig(path = getConfigPath()): Promise<LoadedConfig> {
+  try {
+    const raw = await fs.readFile(path, 'utf8');
+    const parsed = parseConfig(JSON.parse(raw) as unknown);
+    return { ...parsed, path };
+  } catch (error) {
+    const code = isRecord(error) ? error.code : undefined;
+    if (code === 'ENOENT') {
+      return {
+        config: structuredClone(DEFAULT_CONFIG),
+        path,
+        warnings: [],
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      config: structuredClone(DEFAULT_CONFIG),
+      path,
+      warnings: [`failed to load configuration: ${message}`],
+    };
+  }
+}