owflow 0.5.0 → 0.7.0

package/dist/tui.js

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import { readHookStatusSnapshot, readSessionLatestLogs, resolveHooksLogFile, resolveHooksStatusFile } from './hooks/hooks-persistence.js';
+import {} from './types/hook-types.js';
+import { buildHookLogsBody, buildHookRunDetailBody, getActiveDialogHandle, openHookLogPopup } from './tui/hooks-dialogs.js';
+import { buildActiveHooksView, colorForStatus, formatHookLogsMessage, formatHookRunSummary, statusLabelFor, } from './tui/hooks-presenter.js';
+import { materializeSidebar } from './tui/hooks-sidebar.js';
+import { loadSolidRuntime } from './tui/primitives.js';
+export { buildActiveHooksView, buildHookLogsBody, buildHookRunDetailBody, colorForStatus, formatHookLogsMessage, formatHookRunSummary, getActiveDialogHandle, statusLabelFor, };
+const SIDEBAR_SLOT = 'sidebar_content';
+const DEFAULT_STATUS_POLL_MS = 200;
+export const registerActiveHooksSidebar = async (api, directory, loadSolid = loadSolidRuntime) => {
+    const solid = await loadSolid();
+    if (solid === null) {
+        console.warn('[owflow] TUI Solid runtime unavailable; cannot render the active hooks panel.');
+        return false;
+    }
+    const view = buildActiveHooksView(directory);
+    const statusFile = resolveHooksStatusFile(directory);
+    const handles = [];
+    let statuses = new Map();
+    let lastMtime;
+    const sessionEpochs = new Map();
+    const pollingEnabled = process.env.OWFLOW_HOOKS_DISABLED !== '1';
+    if (pollingEnabled) {
+        const renderer = api.renderer;
+        const tick = () => {
+            try {
+                const stat = fs.statSync(statusFile);
+                if (stat.isFile() && lastMtime !== stat.mtimeMs) {
+                    lastMtime = stat.mtimeMs;
+                    const result = readHookStatusSnapshot(statusFile);
+                    if (result.kind === 'ok') {
+                        statuses = new Map(Object.entries(result.snapshot.hooks));
+                    }
+                }
+                else if (!stat.isFile()) {
+                    lastMtime = undefined;
+                }
+            }
+            catch {
+                lastMtime = undefined;
+            }
+            for (const handle of handles) {
+                if (handle.disposed())
+                    continue;
+                if (handle.applyStatuses(statuses)) {
+                    renderer.requestRender();
+                }
+            }
+            for (let i = handles.length - 1; i >= 0; i -= 1) {
+                if (handles[i].disposed())
+                    handles.splice(i, 1);
+            }
+        };
+        const timer = setInterval(tick, DEFAULT_STATUS_POLL_MS);
+        timer.unref?.();
+        api.lifecycle.onDispose(() => {
+            clearInterval(timer);
+            getActiveDialogHandle()?.dispose();
+            for (const handle of handles) {
+                handle.dispose();
+            }
+            handles.length = 0;
+        });
+    }
+    else {
+        api.lifecycle.onDispose(() => {
+            getActiveDialogHandle()?.dispose();
+            for (const handle of handles) {
+                handle.dispose();
+            }
+            handles.length = 0;
+        });
+    }
+    api.slots.register({
+        order: 50,
+        slots: {
+            [SIDEBAR_SLOT]: (ctx, props) => {
+                const sessionID = props?.session_id;
+                const key = sessionID ?? '';
+                const notBefore = sessionEpochs.get(key) ?? (sessionEpochs.set(key, Date.now()), sessionEpochs.get(key));
+                const initialStates = new Map();
+                if (sessionID !== undefined && sessionID.length > 0) {
+                    for (const row of view.rows) {
+                        try {
+                            const rowLogFile = resolveHooksLogFile(directory, row.name);
+                            const sessionLogs = readSessionLatestLogs(rowLogFile, sessionID);
+                            const rec = sessionLogs.get(row.event);
+                            if (rec)
+                                initialStates.set(row.event, rec.status);
+                        }
+                        catch { }
+                    }
+                }
+                const handle = materializeSidebar(view, ctx.theme.current, solid, (row, theme) => {
+                    if (pollingEnabled) {
+                        const rowLogFile = resolveHooksLogFile(directory, row.name);
+                        openHookLogPopup(api, solid, rowLogFile, row, theme, notBefore, sessionID, statusFile, statuses.get(row.event));
+                    }
+                }, () => api.renderer.requestRender(), pollingEnabled, notBefore, sessionID, initialStates);
+                handle.applyStatuses(statuses);
+                handles.push(handle);
+                if (typeof solid.onCleanup === 'function') {
+                    try {
+                        solid.onCleanup(() => {
+                            handle.dispose();
+                            const idx = handles.indexOf(handle);
+                            if (idx !== -1) {
+                                handles.splice(idx, 1);
+                            }
+                        });
+                    }
+                    catch { }
+                }
+                return handle.root;
+            },
+        },
+    });
+    return true;
+};
+const tui = async (api) => {
+    const directory = api.state.path.directory;
+    if (typeof directory !== 'string' || directory.length === 0) {
+        console.warn('[owflow] workspace directory unavailable; cannot render the active hooks panel.');
+        return;
+    }
+    await registerActiveHooksSidebar(api, directory);
+};
+export default { id: 'owflow', tui };

package/dist/types/hook-types.d.ts

@@ -0,0 +1,125 @@
+export declare enum HookEvent {
+    ToolExecuteBefore = "tool.execute.before",
+    ToolExecuteAfter = "tool.execute.after",
+    ToolDefinition = "tool.definition",
+    ChatMessage = "chat.message",
+    ChatParams = "chat.params",
+    ChatHeaders = "chat.headers",
+    CommandExecuteBefore = "command.execute.before",
+    ShellEnv = "shell.env",
+    ExperimentalChatMessagesTransform = "experimental.chat.messages.transform",
+    ExperimentalChatSystemTransform = "experimental.chat.system.transform",
+    ExperimentalSessionCompacting = "experimental.session.compacting",
+    ExperimentalCompactionAutocontinue = "experimental.compaction.autocontinue",
+    ExperimentalTextComplete = "experimental.text.complete",
+    Config = "config",
+    Event = "event",
+    Dispose = "dispose"
+}
+export type DispatchableEvent = `${HookEvent}`;
+export declare const DISPATCHABLE_EVENTS: readonly DispatchableEvent[];
+export declare const HOST_EVENT_NAMES: readonly ["command.executed", "file.edited", "file.watcher.updated", "installation.update-available", "installation.updated", "lsp.client.diagnostics", "lsp.updated", "message.part.removed", "message.part.updated", "message.removed", "message.updated", "permission.replied", "permission.updated", "pty.created", "pty.deleted", "pty.exited", "pty.updated", "server.connected", "server.instance.disposed", "session.compacted", "session.created", "session.deleted", "session.diff", "session.error", "session.idle", "session.status", "session.updated", "todo.updated", "tui.command.execute", "tui.prompt.append", "tui.toast.show", "vcs.branch.updated"];
+export type HostEventName = (typeof HOST_EVENT_NAMES)[number];
+export type HookEventName = DispatchableEvent | HostEventName;
+export declare const HOOK_EVENT_NAMES: readonly HookEventName[];
+export declare const EXCLUDED_EVENT_NAMES: readonly ["permission.ask", "tool", "auth", "provider", "experimental.provider.small_model"];
+export declare const isHostEventName: (value: string) => value is HostEventName;
+/**
+ * Validation digest mode for `scanHooks`.
+ * - `FailFast`: Throws on any validation failure at startup/runtime to prevent
+ *   running with invalid or ambiguous hooks (fail-closed contract).
+ * - `Report`: Collects failures without throwing, allowing UI surfaces (TUI sidebar)
+ *   and test suites to safely inspect hook status without crashing the process.
+ */
+export declare enum HookDigestMode {
+    FailFast = "fail-fast",
+    Report = "report"
+}
+export interface InterpreterResolution {
+    readonly resolved?: string;
+    readonly expected: string;
+    readonly available: boolean;
+}
+export interface HookRegistryEntry {
+    readonly path: string;
+    readonly event: HookEventName;
+    readonly interpreter: InterpreterResolution;
+    readonly status: 'registered' | 'will-fail-closed';
+}
+export interface HookValidationFailure {
+    readonly path: string;
+    readonly error: string;
+}
+export interface HookScan {
+    readonly entries: readonly HookRegistryEntry[];
+    readonly failures: readonly HookValidationFailure[];
+}
+export declare enum HookRunState {
+    IDLE = "idle",
+    PENDING = "pending",
+    SUCCESS = "success",
+    FAILURE = "failure"
+}
+export interface HookRuntimeEntry {
+    readonly status: HookRunState;
+    readonly startedAt: number;
+    readonly finishedAt?: number;
+    readonly durationMs?: number;
+    readonly reason?: string;
+    readonly sessionID?: string;
+}
+export interface HookStatusSnapshot {
+    readonly version: 1;
+    readonly pid: number;
+    readonly workspace: string;
+    readonly updatedAt: number;
+    readonly hooks: Readonly<Record<string, HookRuntimeEntry>>;
+}
+export type HookStatusReadResult = {
+    readonly kind: 'missing' | 'invalid';
+} | {
+    readonly kind: 'ok';
+    readonly snapshot: HookStatusSnapshot;
+};
+export interface HookRunLogRecord {
+    readonly version: 1;
+    readonly runId: string;
+    readonly pid: number;
+    readonly workspace: string;
+    readonly event: HookEventName;
+    readonly hook: string;
+    readonly name: string;
+    readonly sessionID?: string;
+    readonly startedAt: number;
+    readonly finishedAt: number;
+    readonly durationMs: number;
+    readonly status: HookRunState;
+    readonly exitCode?: number | null;
+    readonly signal?: string | null;
+    readonly reason?: string;
+    readonly stdout?: string;
+    readonly stderr?: string;
+}
+export type HookLogReadResult = {
+    readonly kind: 'missing' | 'invalid';
+} | {
+    readonly kind: 'ok';
+    readonly records: readonly HookRunLogRecord[];
+    readonly truncated: boolean;
+};
+export type Dispatcher = (event: HookEventName, input?: unknown, output?: Record<string, unknown>) => Promise<void>;
+export type HookReportRow = Readonly<Record<'path' | 'event' | 'interpreter' | 'status', string>>;
+export interface HookReportInput {
+    readonly entries: readonly HookRegistryEntry[];
+    readonly failures?: readonly HookValidationFailure[];
+    readonly bypassed?: boolean;
+}
+export interface HooksWrapper {
+    readonly dispatch: Dispatcher;
+    readonly snapshot: HookReportInput;
+    dispose(): void;
+}
+export interface HooksWrapperOptions {
+    readonly statusFile?: string;
+    readonly logFile?: string;
+}

package/dist/types/hook-types.js

@@ -0,0 +1,76 @@
+export var HookEvent;
+(function (HookEvent) {
+    HookEvent["ToolExecuteBefore"] = "tool.execute.before";
+    HookEvent["ToolExecuteAfter"] = "tool.execute.after";
+    HookEvent["ToolDefinition"] = "tool.definition";
+    HookEvent["ChatMessage"] = "chat.message";
+    HookEvent["ChatParams"] = "chat.params";
+    HookEvent["ChatHeaders"] = "chat.headers";
+    HookEvent["CommandExecuteBefore"] = "command.execute.before";
+    HookEvent["ShellEnv"] = "shell.env";
+    HookEvent["ExperimentalChatMessagesTransform"] = "experimental.chat.messages.transform";
+    HookEvent["ExperimentalChatSystemTransform"] = "experimental.chat.system.transform";
+    HookEvent["ExperimentalSessionCompacting"] = "experimental.session.compacting";
+    HookEvent["ExperimentalCompactionAutocontinue"] = "experimental.compaction.autocontinue";
+    HookEvent["ExperimentalTextComplete"] = "experimental.text.complete";
+    HookEvent["Config"] = "config";
+    HookEvent["Event"] = "event";
+    HookEvent["Dispose"] = "dispose";
+})(HookEvent || (HookEvent = {}));
+export const DISPATCHABLE_EVENTS = Object.values(HookEvent);
+export const HOST_EVENT_NAMES = [
+    'command.executed',
+    'file.edited',
+    'file.watcher.updated',
+    'installation.update-available',
+    'installation.updated',
+    'lsp.client.diagnostics',
+    'lsp.updated',
+    'message.part.removed',
+    'message.part.updated',
+    'message.removed',
+    'message.updated',
+    'permission.replied',
+    'permission.updated',
+    'pty.created',
+    'pty.deleted',
+    'pty.exited',
+    'pty.updated',
+    'server.connected',
+    'server.instance.disposed',
+    'session.compacted',
+    'session.created',
+    'session.deleted',
+    'session.diff',
+    'session.error',
+    'session.idle',
+    'session.status',
+    'session.updated',
+    'todo.updated',
+    'tui.command.execute',
+    'tui.prompt.append',
+    'tui.toast.show',
+    'vcs.branch.updated',
+];
+export const HOOK_EVENT_NAMES = [...DISPATCHABLE_EVENTS, ...HOST_EVENT_NAMES];
+export const EXCLUDED_EVENT_NAMES = ['permission.ask', 'tool', 'auth', 'provider', 'experimental.provider.small_model'];
+export const isHostEventName = (value) => HOST_EVENT_NAMES.includes(value);
+/**
+ * Validation digest mode for `scanHooks`.
+ * - `FailFast`: Throws on any validation failure at startup/runtime to prevent
+ *   running with invalid or ambiguous hooks (fail-closed contract).
+ * - `Report`: Collects failures without throwing, allowing UI surfaces (TUI sidebar)
+ *   and test suites to safely inspect hook status without crashing the process.
+ */
+export var HookDigestMode;
+(function (HookDigestMode) {
+    HookDigestMode["FailFast"] = "fail-fast";
+    HookDigestMode["Report"] = "report";
+})(HookDigestMode || (HookDigestMode = {}));
+export var HookRunState;
+(function (HookRunState) {
+    HookRunState["IDLE"] = "idle";
+    HookRunState["PENDING"] = "pending";
+    HookRunState["SUCCESS"] = "success";
+    HookRunState["FAILURE"] = "failure";
+})(HookRunState || (HookRunState = {}));

package/dist/types/opencode-types.d.ts

@@ -0,0 +1,13 @@
+export interface OpenCodeConfig {
+    agent: any;
+    command: Record<string, OpenCodeCommand>;
+    skills: any;
+    small_model?: string;
+}
+export interface OpenCodeCommand {
+    template: string;
+    description?: string;
+    agent?: string;
+    model?: string;
+    subtask?: boolean;
+}

package/dist/utils/file-util.d.ts

@@ -0,0 +1,2 @@
+import matter from 'gray-matter';
+export declare const loadMarkdownDir: (dirPath: string) => matter.GrayMatterFile<string>[];

package/dist/utils/file-util.js

@@ -1,12 +1,12 @@
-import matter from "gray-matter";
-import fs from "node:fs";
-import path from "node:path";
-import { PLUGIN_ROOT } from "./plugin-info.js";
+import matter from 'gray-matter';
+import fs from 'node:fs';
+import path from 'node:path';
+import { PLUGIN_ROOT } from './plugin-info.js';
 export const loadMarkdownDir = (dirPath) => {
     const fullPath = path.join(PLUGIN_ROOT, dirPath);
     let files;
     try {
-        files = fs.readdirSync(fullPath).filter((f) => f.endsWith(".md"));
+        files = fs.readdirSync(fullPath).filter((f) => f.endsWith('.md'));
     }
     catch {
         return [];
@@ -14,7 +14,7 @@ export const loadMarkdownDir = (dirPath) => {
     const parsed = [];
     for (const f of files) {
         try {
-            const raw = fs.readFileSync(path.join(fullPath, f), "utf8");
+            const raw = fs.readFileSync(path.join(fullPath, f), 'utf8');
             parsed.push(matter(raw));
         }
         catch (e) {

package/dist/utils/fork-task.d.ts

@@ -0,0 +1,27 @@
+export interface ForkTaskInput {
+    /** Root of all tasks, e.g. the value of `workflowRelativePath(TASKS_DIRECTORY_NAME)`. */
+    taskRoot: string;
+    /** Source task: absolute/relative path or a bare identifier resolved under <taskRoot>/research/ */
+    source: string;
+    /** Kebab-case slug derived by the agent, without date prefix */
+    slug: string;
+    /** Fork point: completed step slug up to which completed_phases are kept */
+    from: string;
+    /** Short description of what the fork should explore (stamped into the fork state) */
+    intent?: string;
+    /** Working directory used to resolve relative paths (defaults to process.cwd()) */
+    cwd?: string;
+}
+export interface ForkTaskResult {
+    forkPath: string;
+    forkName: string;
+    forkPoint: string;
+}
+/** Lowercase kebab-case, exactly 3-5 words of [a-z0-9] (Task Name Generation convention). */
+export declare const RESEARCH_SLUG_PATTERN: RegExp;
+/**
+ * Copies the whole source task directory into a new date-prefixed directory
+ * named from the slug, then trims the copied state so the fork continues
+ * from the fork point onwards. The source task is never modified.
+ */
+export declare const forkTask: (input: ForkTaskInput) => ForkTaskResult;

package/dist/utils/fork-task.js

@@ -1,10 +1,11 @@
-import fs from "node:fs";
-import path from "node:path";
-import yaml from "yaml";
-import { parseYamlFile } from "./yaml-structure.js";
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'yaml';
+import { RESEARCH_DIRECTORY_NAME, TASKS_DIRECTORY_NAME, workflowRelativePath } from './workflow-paths.js';
+import { parseYamlFile } from './yaml-structure.js';
 /** Lowercase kebab-case, exactly 3-5 words of [a-z0-9] (Task Name Generation convention). */
 export const RESEARCH_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+){2,4}$/;
-const FORK_TERMINAL_STEP = "research-completed";
+const FORK_TERMINAL_STEP = 'research-completed';
 /**
  * Copies the whole source task directory into a new date-prefixed directory
  * named from the slug, then trims the copied state so the fork continues
@@ -16,30 +17,27 @@ export const forkTask = (input) => {
         throw new Error("INVALID_NAME: slug must be lowercase kebab-case, 3-5 words of [a-z0-9] (e.g. 'compare-caching-strategies')");
     }
     const taskRoot = path.resolve(cwd, input.taskRoot);
-    const researchRoot = path.join(taskRoot, "research");
-    const sourceDir = [
-        path.resolve(cwd, input.source),
-        path.resolve(researchRoot, input.source),
-    ].find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isDirectory());
+    const researchRoot = path.join(taskRoot, 'research');
+    const sourceDir = [path.resolve(cwd, input.source), path.resolve(researchRoot, input.source)].find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isDirectory());
     if (sourceDir === undefined) {
-        throw new Error(`INVALID_SOURCE: no task directory at ${input.source}. Hint: pass the task path or a directory name under .owflow/tasks/research/.`);
+        throw new Error(`INVALID_SOURCE: no task directory at ${input.source}. Hint: pass the task path or a directory name under ${workflowRelativePath(TASKS_DIRECTORY_NAME, RESEARCH_DIRECTORY_NAME)}/.`);
     }
     if (!sourceDir.startsWith(researchRoot + path.sep)) {
-        throw new Error(`INVALID_SOURCE: ${input.source} is not a research task directory under .owflow/tasks/research/.`);
+        throw new Error(`INVALID_SOURCE: ${input.source} is not a research task directory under ${workflowRelativePath(TASKS_DIRECTORY_NAME, RESEARCH_DIRECTORY_NAME)}/.`);
     }
-    const parsedSourceState = parseYamlFile(path.join(sourceDir, "orchestrator-state.yml"));
+    const parsedSourceState = parseYamlFile(path.join(sourceDir, 'orchestrator-state.yml'));
     if (!parsedSourceState.ok || !parsedSourceState.data) {
         throw new Error(`INVALID_SOURCE: ${parsedSourceState.error ?? `no orchestrator-state.yml in ${input.source}`}`);
     }
     const sourceState = parsedSourceState.data;
     const completed = Array.isArray(sourceState?.orchestrator?.completed_phases)
-        ? sourceState.orchestrator.completed_phases.filter((s) => typeof s === "string")
+        ? sourceState.orchestrator.completed_phases.filter((s) => typeof s === 'string')
         : [];
     if (input.from === FORK_TERMINAL_STEP) {
         throw new Error(`UNKNOWN_STEP: ${FORK_TERMINAL_STEP} is not a valid fork point — nothing diverges after completion.`);
     }
     if (!completed.includes(input.from)) {
-        throw new Error(`UNKNOWN_STEP: ${input.from} is not completed in the source task. Completed steps: ${completed.join(", ") || "none"}`);
+        throw new Error(`UNKNOWN_STEP: ${input.from} is not completed in the source task. Completed steps: ${completed.join(', ') || 'none'}`);
     }
     const forkName = `${new Date().toISOString().slice(0, 10)}-${input.slug}`;
     const forkPath = path.join(researchRoot, forkName);
@@ -50,11 +48,8 @@ export const forkTask = (input) => {
     const forkState = structuredClone(sourceState);
     forkState.orchestrator.started_phase = null;
     forkState.orchestrator.completed_phases = completed.slice(0, completed.indexOf(input.from) + 1);
-    forkState.orchestrator.entry_point = "research-fork";
-    forkState.orchestrator.task_path = path
-        .relative(cwd, forkPath)
-        .split(path.sep)
-        .join("/");
+    forkState.orchestrator.entry_point = 'research-fork';
+    forkState.orchestrator.task_path = path.relative(cwd, forkPath).split(path.sep).join('/');
     forkState.orchestrator.options = {
         ...(forkState.orchestrator.options ?? {}),
         fork_information: {
@@ -66,9 +61,9 @@ export const forkTask = (input) => {
     };
     forkState.task = {
         ...forkState.task,
-        status: "in_progress",
-        title: `${forkState.task?.title ?? "Research task"} (fork of ${path.basename(sourceDir)})`,
+        status: 'in_progress',
+        title: `${forkState.task?.title ?? 'Research task'} (fork of ${path.basename(sourceDir)})`,
     };
-    fs.writeFileSync(path.join(forkPath, "orchestrator-state.yml"), yaml.stringify(forkState), "utf8");
+    fs.writeFileSync(path.join(forkPath, 'orchestrator-state.yml'), yaml.stringify(forkState), 'utf8');
     return { forkPath, forkName, forkPoint: input.from };
 };

package/dist/utils/plugin-info.d.ts

@@ -0,0 +1,3 @@
+export declare const PLUGIN_ROOT: string;
+export declare const readPluginVersion: (pluginRoot?: string) => string;
+export declare const PLUGIN_VERSION: string;

package/dist/utils/plugin-info.js

@@ -1,17 +1,15 @@
-import path from "node:path";
-import fs from "node:fs";
-import { fileURLToPath } from "node:url";
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export const PLUGIN_ROOT = path.join(__dirname, ".."); // Points to dist/ where skills/commands/agents are copied
-const UNKNOWN_VERSION = "unknown";
+export const PLUGIN_ROOT = path.join(__dirname, '..'); // Points to dist/ where skills/commands/agents are copied
+const UNKNOWN_VERSION = 'unknown';
 export const readPluginVersion = (pluginRoot = PLUGIN_ROOT) => {
     try {
-        const packageJsonPath = path.join(pluginRoot, "..", "package.json");
-        const raw = fs.readFileSync(packageJsonPath, "utf8");
+        const packageJsonPath = path.join(pluginRoot, '..', 'package.json');
+        const raw = fs.readFileSync(packageJsonPath, 'utf8');
         const version = JSON.parse(raw).version;
-        return typeof version === "string" && version.length > 0
-            ? version
-            : UNKNOWN_VERSION;
+        return typeof version === 'string' && version.length > 0 ? version : UNKNOWN_VERSION;
     }
     catch {
         return UNKNOWN_VERSION;

package/dist/utils/workflow-paths.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Canonical owflow directory names. Host projects and every internal surface
+ * (server plugin, CLI, TUI, hooks, tools) refer to these constants instead of
+ * repeating path fragments.
+ */
+export declare const WORKFLOW_DIRECTORY_NAME = ".owflow";
+export declare const HOOKS_DIRECTORY_NAME = "hooks";
+export declare const TASKS_DIRECTORY_NAME = "tasks";
+export declare const DOCS_DIRECTORY_NAME = "docs";
+export declare const RESEARCH_DIRECTORY_NAME = "research";
+export declare const workflowPath: (root: string, ...segments: readonly string[]) => string;
+export declare const workflowRelativePath: (...segments: readonly string[]) => string;
+export declare const hooksDirectory: (root: string) => string;
+export declare const tasksDirectory: (root: string) => string;
+export declare const docsDirectory: (root: string) => string;
+export declare const hooksLocationLabel: string;
+export declare const tasksLocationLabel: string;

package/dist/utils/workflow-paths.js

@@ -0,0 +1,18 @@
+import path from 'node:path';
+/**
+ * Canonical owflow directory names. Host projects and every internal surface
+ * (server plugin, CLI, TUI, hooks, tools) refer to these constants instead of
+ * repeating path fragments.
+ */
+export const WORKFLOW_DIRECTORY_NAME = '.owflow';
+export const HOOKS_DIRECTORY_NAME = 'hooks';
+export const TASKS_DIRECTORY_NAME = 'tasks';
+export const DOCS_DIRECTORY_NAME = 'docs';
+export const RESEARCH_DIRECTORY_NAME = 'research';
+export const workflowPath = (root, ...segments) => path.join(root, WORKFLOW_DIRECTORY_NAME, ...segments);
+export const workflowRelativePath = (...segments) => [WORKFLOW_DIRECTORY_NAME, ...segments].join('/');
+export const hooksDirectory = (root) => workflowPath(root, HOOKS_DIRECTORY_NAME);
+export const tasksDirectory = (root) => workflowPath(root, TASKS_DIRECTORY_NAME);
+export const docsDirectory = (root) => workflowPath(root, DOCS_DIRECTORY_NAME);
+export const hooksLocationLabel = workflowRelativePath(HOOKS_DIRECTORY_NAME);
+export const tasksLocationLabel = workflowRelativePath(TASKS_DIRECTORY_NAME);

package/dist/utils/yaml-structure.d.ts

@@ -0,0 +1,7 @@
+export interface ParsedYaml {
+    ok: boolean;
+    data?: any;
+    error?: string;
+}
+export declare const parseYamlFile: (absolutePath: string) => ParsedYaml;
+export declare const findStructuralErrors: (templateObj: any, targetObj: any, currentPath?: string) => string[];

package/dist/utils/yaml-structure.js

@@ -1,30 +1,26 @@
-import fs from "node:fs";
-import yaml from "yaml";
+import fs from 'node:fs';
+import yaml from 'yaml';
 export const parseYamlFile = (absolutePath) => {
     try {
-        const fileContent = fs.readFileSync(absolutePath, "utf8");
+        const fileContent = fs.readFileSync(absolutePath, 'utf8');
         return { ok: true, data: yaml.parse(fileContent) };
     }
     catch (error) {
         return { ok: false, error: error.message };
     }
 };
-export const findStructuralErrors = (templateObj, targetObj, currentPath = "") => {
+export const findStructuralErrors = (templateObj, targetObj, currentPath = '') => {
     const errors = [];
-    if (typeof templateObj !== "object" || templateObj === null) {
+    if (typeof templateObj !== 'object' || templateObj === null) {
         return errors;
     }
     for (const key of Object.keys(templateObj)) {
         const newPath = currentPath ? `${currentPath}.${key}` : key;
-        if (typeof targetObj !== "object" ||
-            targetObj === null ||
-            !(key in targetObj)) {
+        if (typeof targetObj !== 'object' || targetObj === null || !(key in targetObj)) {
             errors.push(`Missing key: ${newPath}`);
             continue;
         }
-        if (typeof templateObj[key] === "object" &&
-            templateObj[key] !== null &&
-            !Array.isArray(templateObj[key])) {
+        if (typeof templateObj[key] === 'object' && templateObj[key] !== null && !Array.isArray(templateObj[key])) {
             errors.push(...findStructuralErrors(templateObj[key], targetObj[key], newPath));
         }
     }