gsd-unsupervised 1.0.0

package/dist/lifecycle.test.js

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest';
+import { GoalLifecyclePhase, GoalStateMachine, } from './lifecycle.js';
+describe('GoalStateMachine transitions', () => {
+    it('starts in the new phase with zeroed counters', () => {
+        const sm = new GoalStateMachine('Test goal');
+        const progress = sm.getProgress();
+        expect(progress.phase).toBe(GoalLifecyclePhase.New);
+        expect(progress.currentPhaseNumber).toBe(0);
+        expect(progress.totalPhases).toBe(0);
+        expect(progress.currentPlanIndex).toBe(0);
+        expect(progress.totalPlansInPhase).toBe(0);
+        expect(sm.isTerminal()).toBe(false);
+    });
+    it('allows valid forward transitions based on LIFECYCLE_TRANSITIONS', () => {
+        const sm = new GoalStateMachine('Test goal');
+        // new -> initializing_project
+        sm.advance(GoalLifecyclePhase.InitializingProject);
+        expect(sm.getPhase()).toBe(GoalLifecyclePhase.InitializingProject);
+        // initializing_project -> creating_roadmap
+        sm.advance(GoalLifecyclePhase.CreatingRoadmap);
+        expect(sm.getPhase()).toBe(GoalLifecyclePhase.CreatingRoadmap);
+        // creating_roadmap -> planning_phase
+        sm.advance(GoalLifecyclePhase.PlanningPhase);
+        expect(sm.getPhase()).toBe(GoalLifecyclePhase.PlanningPhase);
+        // planning_phase -> executing_plan
+        sm.advance(GoalLifecyclePhase.ExecutingPlan);
+        expect(sm.getPhase()).toBe(GoalLifecyclePhase.ExecutingPlan);
+        // executing_plan can transition to itself (multiple plans in a phase)
+        sm.advance(GoalLifecyclePhase.ExecutingPlan);
+        expect(sm.getPhase()).toBe(GoalLifecyclePhase.ExecutingPlan);
+        // executing_plan -> phase_complete
+        sm.advance(GoalLifecyclePhase.PhaseComplete);
+        expect(sm.getPhase()).toBe(GoalLifecyclePhase.PhaseComplete);
+        // phase_complete -> complete
+        sm.advance(GoalLifecyclePhase.Complete);
+        expect(sm.getPhase()).toBe(GoalLifecyclePhase.Complete);
+        expect(sm.isTerminal()).toBe(true);
+        expect(sm.isComplete()).toBe(true);
+    });
+    it('throws helpful error for invalid transitions with current, target, and allowed set', () => {
+        const sm = new GoalStateMachine('Test goal');
+        expect(() => sm.advance(GoalLifecyclePhase.PlanningPhase)).toThrowError(/Invalid transition: new → planning_phase\. Allowed transitions from 'new': \[initializing_project]/);
+    });
+    it('moves to failed phase and records error when fail() is called', () => {
+        const sm = new GoalStateMachine('Test goal');
+        sm.fail('something went wrong');
+        const progress = sm.getProgress();
+        expect(progress.phase).toBe(GoalLifecyclePhase.Failed);
+        expect(progress.error).toBe('something went wrong');
+        expect(sm.isFailed()).toBe(true);
+        expect(sm.isTerminal()).toBe(true);
+    });
+});
+describe('GoalStateMachine getNextCommand', () => {
+    it('returns /gsd/new-project for the initial new phase', () => {
+        const sm = new GoalStateMachine('Test goal');
+        const cmd = sm.getNextCommand();
+        expect(cmd).not.toBeNull();
+        expect(cmd.command).toBe('/gsd/new-project');
+        expect(cmd.args).toBeUndefined();
+        expect(cmd.description).toMatch(/Initialize project/i);
+    });
+    it('returns /gsd/create-roadmap after initializing_project', () => {
+        const sm = new GoalStateMachine('Test goal');
+        sm.advance(GoalLifecyclePhase.InitializingProject);
+        const cmd = sm.getNextCommand();
+        expect(cmd).not.toBeNull();
+        expect(cmd.command).toBe('/gsd/create-roadmap');
+        expect(cmd.args).toBeUndefined();
+        expect(cmd.description).toMatch(/Create roadmap/i);
+    });
+    it('returns /gsd/plan-phase N in creating_roadmap using currentPhaseNumber', () => {
+        const sm = new GoalStateMachine('Test goal');
+        sm.advance(GoalLifecyclePhase.InitializingProject);
+        sm.advance(GoalLifecyclePhase.CreatingRoadmap);
+        sm.setPhaseInfo(1, 3);
+        const cmd = sm.getNextCommand();
+        expect(cmd).not.toBeNull();
+        expect(cmd.command).toBe('/gsd/plan-phase');
+        expect(cmd.args).toBe('1');
+        expect(cmd.description).toContain('phase 1');
+    });
+    it('returns null while in planning_phase or executing_plan', () => {
+        const sm = new GoalStateMachine('Test goal');
+        sm.advance(GoalLifecyclePhase.InitializingProject);
+        sm.advance(GoalLifecyclePhase.CreatingRoadmap);
+        sm.advance(GoalLifecyclePhase.PlanningPhase);
+        expect(sm.getNextCommand()).toBeNull();
+        sm.advance(GoalLifecyclePhase.ExecutingPlan);
+        expect(sm.getNextCommand()).toBeNull();
+    });
+    it('returns /gsd/plan-phase for the next phase when phase_complete and more phases remain', () => {
+        const sm = new GoalStateMachine('Test goal');
+        sm.advance(GoalLifecyclePhase.InitializingProject);
+        sm.advance(GoalLifecyclePhase.CreatingRoadmap);
+        sm.setPhaseInfo(1, 3);
+        sm.advance(GoalLifecyclePhase.PlanningPhase);
+        sm.advance(GoalLifecyclePhase.ExecutingPlan);
+        sm.advance(GoalLifecyclePhase.PhaseComplete);
+        const cmd = sm.getNextCommand();
+        expect(cmd).not.toBeNull();
+        expect(cmd.command).toBe('/gsd/plan-phase');
+        expect(cmd.args).toBe('2');
+        expect(cmd.description).toContain('phase 2');
+    });
+    it('returns null when phase_complete and already on the final phase', () => {
+        const sm = new GoalStateMachine('Test goal');
+        sm.advance(GoalLifecyclePhase.InitializingProject);
+        sm.advance(GoalLifecyclePhase.CreatingRoadmap);
+        sm.setPhaseInfo(3, 3);
+        sm.advance(GoalLifecyclePhase.PlanningPhase);
+        sm.advance(GoalLifecyclePhase.ExecutingPlan);
+        sm.advance(GoalLifecyclePhase.PhaseComplete);
+        expect(sm.getNextCommand()).toBeNull();
+    });
+});

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+import { type Logger } from 'pino';
+export type { Logger } from 'pino';
+export declare function createLogger(options: {
+    level?: string;
+    pretty?: boolean;
+}): Logger;
+export declare function createChildLogger(parent: Logger, component: string): Logger;
+export declare function initLogger(options: {
+    level?: string;
+    pretty?: boolean;
+}): Logger;
+export declare function getLogger(): Logger;

package/dist/logger.js

@@ -0,0 +1,31 @@
+import pino from 'pino';
+export function createLogger(options) {
+    const { level = 'info', pretty = false } = options;
+    if (pretty) {
+        return pino({
+            level,
+            transport: {
+                target: 'pino-pretty',
+                options: {
+                    colorize: true,
+                    translateTime: 'SYS:HH:MM:ss',
+                },
+            },
+        });
+    }
+    return pino({ level });
+}
+export function createChildLogger(parent, component) {
+    return parent.child({ component });
+}
+let defaultLogger;
+export function initLogger(options) {
+    defaultLogger = createLogger(options);
+    return defaultLogger;
+}
+export function getLogger() {
+    if (!defaultLogger) {
+        throw new Error('Logger not initialized — call initLogger() first');
+    }
+    return defaultLogger;
+}

package/dist/notifier.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Twilio SMS outbound only (alerts on goal complete/fail/pause).
+ * No inbound SMS or webhook: adding goals or todos via SMS is not implemented.
+ * Reads TWILIO_* from process.env; single POST to Twilio Messages API.
+ */
+export declare function sendSms(message: string): Promise<void>;

package/dist/notifier.js

@@ -0,0 +1,37 @@
+function getEnv(name) {
+    const v = process.env[name];
+    if (!v || v.trim() === '') {
+        throw new Error(`Missing required env var: ${name}`);
+    }
+    return v.trim();
+}
+/**
+ * Twilio SMS outbound only (alerts on goal complete/fail/pause).
+ * No inbound SMS or webhook: adding goals or todos via SMS is not implemented.
+ * Reads TWILIO_* from process.env; single POST to Twilio Messages API.
+ */
+export async function sendSms(message) {
+    const accountSid = getEnv('TWILIO_ACCOUNT_SID');
+    const authToken = getEnv('TWILIO_AUTH_TOKEN');
+    const from = getEnv('TWILIO_FROM');
+    const to = getEnv('TWILIO_TO');
+    const url = `https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(accountSid)}/Messages.json`;
+    const body = new URLSearchParams({
+        From: from,
+        To: to,
+        Body: message,
+    });
+    const auth = Buffer.from(`${accountSid}:${authToken}`, 'utf-8').toString('base64');
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+            Authorization: `Basic ${auth}`,
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Twilio SMS failed (${res.status} ${res.statusText})${text ? `: ${text}` : ''}`);
+    }
+}

package/dist/orchestrator.d.ts

@@ -0,0 +1,35 @@
+import type { AutopilotConfig } from './config.js';
+import type { Logger } from './logger.js';
+import type { Goal } from './goals.js';
+import type { SessionLogContext } from './session-log.js';
+import { type GsdCommand } from './lifecycle.js';
+import type { StateSnapshot } from './state-types.js';
+import type { ResumeFrom } from './session-log.js';
+export declare function reportProgress(options: {
+    stateMdPath: string;
+    logger: Logger;
+    onProgress?: (snapshot: StateSnapshot) => void;
+    expectedPhase: number;
+    expectedSummaryPath?: string;
+}): Promise<void>;
+export interface AgentResult {
+    success: boolean;
+    output?: string;
+    error?: string;
+}
+export type AgentInvoker = (command: GsdCommand, workspaceDir: string, logger: Logger, logContext?: SessionLogContext) => Promise<AgentResult>;
+export declare function orchestrateGoal(options: {
+    goal: Goal;
+    config: AutopilotConfig;
+    logger: Logger;
+    agent?: AgentInvoker;
+    isShuttingDown: () => boolean;
+    onProgress?: (snapshot: StateSnapshot) => void;
+    /** When set, orchestrator will resume from this phase/plan (used in 05-03). */
+    resumeFrom?: ResumeFrom | null;
+    /**
+     * Hint to skip re-running /gsd/plan-phase for phases before this 1-based phase index.
+     * Plans will still be discovered/executed for skipped phases.
+     */
+    skipToPhase?: number | null;
+}): Promise<void>;