heyio 1.13.0 → 3.0.0

package/src/store/schedules.ts

@@ -0,0 +1,199 @@
+import { CronExpressionParser } from 'cron-parser';
+import { createChildLogger } from '../logging/logger.js';
+import { getDatabase } from './db.js';
+
+const logger = () => createChildLogger('schedules-store');
+
+export type ScheduleTargetType = 'squad' | 'orchestrator';
+
+export interface Schedule {
+	id: string;
+	name: string;
+	targetType: ScheduleTargetType;
+	targetId: string | null;
+	cron: string;
+	prompt: string;
+	enabled: boolean;
+	lastRun: string | null;
+	nextRun: string | null;
+	createdAt: string;
+}
+
+/**
+ * Calculate the next run time from a cron expression.
+ */
+export function calculateNextRun(cron: string, from?: Date): Date {
+	const interval = CronExpressionParser.parse(cron, { currentDate: from ?? new Date() });
+	return interval.next().toDate();
+}
+
+/**
+ * Create a new schedule.
+ */
+export async function createSchedule(params: {
+	name: string;
+	targetType: ScheduleTargetType;
+	targetId?: string;
+	cron: string;
+	prompt: string;
+	enabled?: boolean;
+}): Promise<Schedule> {
+	const db = getDatabase();
+	const id = crypto.randomUUID();
+	const enabled = params.enabled ?? true;
+	const nextRun = enabled ? calculateNextRun(params.cron).toISOString() : null;
+
+	await db.execute({
+		sql: `INSERT INTO schedules (id, name, target_type, target_id, cron, prompt, enabled, next_run)
+		      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+		args: [
+			id,
+			params.name,
+			params.targetType,
+			params.targetId ?? null,
+			params.cron,
+			params.prompt,
+			enabled ? 1 : 0,
+			nextRun,
+		],
+	});
+
+	logger().info({ id, name: params.name, cron: params.cron }, 'Schedule created');
+
+	return {
+		id,
+		name: params.name,
+		targetType: params.targetType,
+		targetId: params.targetId ?? null,
+		cron: params.cron,
+		prompt: params.prompt,
+		enabled,
+		lastRun: null,
+		nextRun,
+		createdAt: new Date().toISOString(),
+	};
+}
+
+/**
+ * List all schedules with optional enabled filter.
+ */
+export async function listSchedules(enabledOnly?: boolean): Promise<Schedule[]> {
+	const db = getDatabase();
+	const sql = enabledOnly
+		? 'SELECT * FROM schedules WHERE enabled = 1 ORDER BY next_run ASC'
+		: 'SELECT * FROM schedules ORDER BY created_at DESC';
+	const result = await db.execute(sql);
+	return result.rows.map(rowToSchedule);
+}
+
+/**
+ * Get a single schedule by ID.
+ */
+export async function getSchedule(id: string): Promise<Schedule | null> {
+	const db = getDatabase();
+	const result = await db.execute({ sql: 'SELECT * FROM schedules WHERE id = ?', args: [id] });
+	if (result.rows.length === 0) return null;
+	return rowToSchedule(result.rows[0]);
+}
+
+/**
+ * Update a schedule (partial update).
+ */
+export async function updateSchedule(
+	id: string,
+	updates: Partial<Pick<Schedule, 'name' | 'cron' | 'prompt' | 'enabled'>>,
+): Promise<void> {
+	const db = getDatabase();
+	const sets: string[] = [];
+	const args: (string | number | null)[] = [];
+
+	if (updates.name !== undefined) {
+		sets.push('name = ?');
+		args.push(updates.name);
+	}
+	if (updates.cron !== undefined) {
+		sets.push('cron = ?');
+		args.push(updates.cron);
+		// Recalculate next_run
+		sets.push('next_run = ?');
+		args.push(calculateNextRun(updates.cron).toISOString());
+	}
+	if (updates.prompt !== undefined) {
+		sets.push('prompt = ?');
+		args.push(updates.prompt);
+	}
+	if (updates.enabled !== undefined) {
+		sets.push('enabled = ?');
+		args.push(updates.enabled ? 1 : 0);
+		if (updates.enabled && !updates.cron) {
+			// Need to recalculate next_run from existing cron
+			const existing = await getSchedule(id);
+			if (existing) {
+				sets.push('next_run = ?');
+				args.push(calculateNextRun(existing.cron).toISOString());
+			}
+		}
+		if (!updates.enabled) {
+			sets.push('next_run = ?');
+			args.push(null);
+		}
+	}
+
+	if (sets.length === 0) return;
+	args.push(id);
+
+	await db.execute({
+		sql: `UPDATE schedules SET ${sets.join(', ')} WHERE id = ?`,
+		args,
+	});
+}
+
+/**
+ * Delete a schedule.
+ */
+export async function deleteSchedule(id: string): Promise<void> {
+	const db = getDatabase();
+	await db.execute({ sql: 'DELETE FROM schedules WHERE id = ?', args: [id] });
+}
+
+/**
+ * Mark a schedule as fired (update last_run and next_run).
+ */
+export async function markScheduleFired(id: string, cron: string): Promise<void> {
+	const db = getDatabase();
+	const now = new Date().toISOString();
+	const nextRun = calculateNextRun(cron).toISOString();
+
+	await db.execute({
+		sql: 'UPDATE schedules SET last_run = ?, next_run = ? WHERE id = ?',
+		args: [now, nextRun, id],
+	});
+}
+
+/**
+ * Get all schedules that are due to fire (next_run <= now and enabled).
+ */
+export async function getDueSchedules(): Promise<Schedule[]> {
+	const db = getDatabase();
+	const now = new Date().toISOString();
+	const result = await db.execute({
+		sql: 'SELECT * FROM schedules WHERE enabled = 1 AND next_run IS NOT NULL AND next_run <= ?',
+		args: [now],
+	});
+	return result.rows.map(rowToSchedule);
+}
+
+function rowToSchedule(row: Record<string, unknown>): Schedule {
+	return {
+		id: row.id as string,
+		name: row.name as string,
+		targetType: row.target_type as ScheduleTargetType,
+		targetId: row.target_id as string | null,
+		cron: row.cron as string,
+		prompt: row.prompt as string,
+		enabled: (row.enabled as number) === 1,
+		lastRun: row.last_run as string | null,
+		nextRun: row.next_run as string | null,
+		createdAt: row.created_at as string,
+	};
+}

package/src/wiki/index.ts

@@ -0,0 +1,12 @@
+export {
+	initWiki,
+	ensureSquadWiki,
+	listWikiPages,
+	readWikiPage,
+	writeWikiPage,
+	searchWiki,
+	getSquadScopes,
+	getOrchestratorScopes,
+	getPageListing,
+} from './store.js';
+export type { WikiScope, WikiPage, WikiSearchResult } from './store.js';

package/src/wiki/store.ts

@@ -0,0 +1,139 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createChildLogger } from '../logging/logger.js';
+
+const logger = () => createChildLogger('wiki');
+
+export type WikiScope = 'io' | 'shared' | string; // string = squad name
+
+export interface WikiPage {
+	scope: string;
+	name: string;
+	content: string;
+}
+
+export interface WikiSearchResult {
+	scope: string;
+	name: string;
+	matches: string[];
+}
+
+let wikiRoot = '';
+
+/**
+ * Initialize the wiki directory structure.
+ */
+export function initWiki(dataDir: string): void {
+	wikiRoot = join(dataDir, 'wiki');
+	mkdirSync(join(wikiRoot, 'io'), { recursive: true });
+	mkdirSync(join(wikiRoot, 'shared'), { recursive: true });
+	mkdirSync(join(wikiRoot, 'squads'), { recursive: true });
+	logger().info({ wikiRoot }, 'Wiki initialized');
+}
+
+/**
+ * Ensure a squad wiki folder exists.
+ */
+export function ensureSquadWiki(squadName: string): void {
+	const dir = join(wikiRoot, 'squads', squadName);
+	mkdirSync(dir, { recursive: true });
+}
+
+function scopeDir(scope: WikiScope): string {
+	if (scope === 'io') return join(wikiRoot, 'io');
+	if (scope === 'shared') return join(wikiRoot, 'shared');
+	return join(wikiRoot, 'squads', scope);
+}
+
+/**
+ * List all page names in a scope.
+ */
+export function listWikiPages(scope: WikiScope): string[] {
+	const dir = scopeDir(scope);
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir)
+		.filter((f) => f.endsWith('.md'))
+		.map((f) => f.replace(/\.md$/, ''));
+}
+
+/**
+ * Read a wiki page. Returns null if it doesn't exist.
+ */
+export function readWikiPage(scope: WikiScope, pageName: string): WikiPage | null {
+	const filePath = join(scopeDir(scope), `${pageName}.md`);
+	if (!existsSync(filePath)) return null;
+	const content = readFileSync(filePath, 'utf-8');
+	return { scope, name: pageName, content };
+}
+
+/**
+ * Write (create or overwrite) a wiki page.
+ */
+export function writeWikiPage(scope: WikiScope, pageName: string, content: string): WikiPage {
+	const dir = scopeDir(scope);
+	mkdirSync(dir, { recursive: true });
+	const filePath = join(dir, `${pageName}.md`);
+	writeFileSync(filePath, content, 'utf-8');
+	logger().info({ scope, pageName }, 'Wiki page written');
+	return { scope, name: pageName, content };
+}
+
+/**
+ * Search wiki pages by keyword across one or more scopes.
+ * Returns matching pages with context lines.
+ */
+export function searchWiki(keyword: string, scopes: WikiScope[]): WikiSearchResult[] {
+	const results: WikiSearchResult[] = [];
+	const lower = keyword.toLowerCase();
+
+	for (const scope of scopes) {
+		const pages = listWikiPages(scope);
+		for (const pageName of pages) {
+			const page = readWikiPage(scope, pageName);
+			if (!page) continue;
+
+			const lines = page.content.split('\n');
+			const matches: string[] = [];
+			for (const line of lines) {
+				if (line.toLowerCase().includes(lower)) {
+					matches.push(line.trim());
+				}
+			}
+
+			if (matches.length > 0) {
+				results.push({ scope, name: pageName, matches: matches.slice(0, 5) });
+			}
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Get accessible scopes for a squad agent.
+ */
+export function getSquadScopes(squadName: string): WikiScope[] {
+	return ['shared', squadName];
+}
+
+/**
+ * Get accessible scopes for the orchestrator.
+ */
+export function getOrchestratorScopes(): WikiScope[] {
+	return ['io', 'shared'];
+}
+
+/**
+ * Get a summary of available pages for injection into system prompts.
+ */
+export function getPageListing(scopes: WikiScope[]): string {
+	const sections: string[] = [];
+	for (const scope of scopes) {
+		const pages = listWikiPages(scope);
+		if (pages.length > 0) {
+			const label = scope === 'io' ? 'IO' : scope === 'shared' ? 'Shared' : `Squad (${scope})`;
+			sections.push(`${label}: ${pages.join(', ')}`);
+		}
+	}
+	return sections.length > 0 ? sections.join('\n') : '(no wiki pages yet)';
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src"
+	},
+	"include": ["src/**/*"],
+	"references": [{ "path": "../shared" }]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Michael Jolley
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.