@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/habits/habit-migration.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateHabitsFromTaskSystem = migrateHabitsFromTaskSystem;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const habit_parser_1 = require("./habit-parser");
+const habit_runtime_state_1 = require("./habit-runtime-state");
+const habit_lifecycle_1 = require("./habit-lifecycle");
+const frontmatter_1 = require("../../util/frontmatter");
+/** Fields that belong to the task system and should be stripped from migrated habits. */
+const TASK_ONLY_FIELDS = new Set([
+    "type",
+    "category",
+    "requester",
+    "validator",
+    "scheduledAt",
+    "updated",
+    "depends_on",
+    "parent_task",
+    "artifacts",
+]);
+/** Regex matching the YYYY-MM-DD-HHMM- timestamp prefix in task filenames. */
+const TIMESTAMP_PREFIX = /^\d{4}-\d{2}-\d{2}-\d{4}-/;
+/** Map known old task statuses while preserving explicit unknown values for fail-closed parsing. */
+function mapStatus(taskStatus, wasExplicit) {
+    if (!wasExplicit || taskStatus === "processing")
+        return { skip: false, status: "active" };
+    if (taskStatus === "done")
+        return { skip: true, status: taskStatus };
+    return { skip: false, status: taskStatus };
+}
+/** Strip timestamp prefix from filename to get the slug name. */
+function stripTimestampPrefix(filename) {
+    return filename.replace(TIMESTAMP_PREFIX, "");
+}
+/**
+ * Migrate habit files from the old `tasks/habits/` location to the new `habits/` bundle root.
+ * - Strips timestamp prefix from filenames
+ * - Maps task statuses to habit statuses
+ * - Strips task-only frontmatter fields
+ * - Preserves body text
+ * - Skips done habits, README files, and already-migrated habits
+ * - No-op if `tasks/habits/` does not exist
+ */
+function migrateHabitsFromTaskSystem(bundleRoot) {
+    const oldHabitsDir = path.join(bundleRoot, "tasks", "habits");
+    if (!fs.existsSync(oldHabitsDir)) {
+        return;
+    }
+    let files;
+    try {
+        files = fs.readdirSync(oldHabitsDir);
+    }
+    catch {
+        /* v8 ignore next -- race condition: dir removed between existsSync and readdirSync @preserve */
+        return;
+    }
+    const mdFiles = files.filter((f) => f.endsWith(".md") && f !== "README.md");
+    if (mdFiles.length === 0)
+        return;
+    const newHabitsDir = path.join(bundleRoot, "habits");
+    fs.mkdirSync(newHabitsDir, { recursive: true });
+    let migratedCount = 0;
+    for (const file of mdFiles) {
+        const slugName = stripTimestampPrefix(file);
+        const targetPath = path.join(newHabitsDir, slugName);
+        const sourcePath = path.join(oldHabitsDir, file);
+        let content;
+        try {
+            content = fs.readFileSync(sourcePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        // Parse frontmatter and body
+        const lines = content.split(/\r?\n/);
+        if (lines[0]?.trim() !== "---")
+            continue;
+        const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+        if (closing === -1)
+            continue;
+        const rawFrontmatter = lines.slice(1, closing).join("\n");
+        const body = lines.slice(closing + 1).join("\n").trim();
+        if (!(0, habit_parser_1.isHabitFrontmatterSyntaxValid)(rawFrontmatter))
+            continue;
+        const frontmatter = (0, frontmatter_1.parseFrontmatter)(rawFrontmatter);
+        // Check status — skip done habits
+        const hasExplicitStatus = Object.prototype.hasOwnProperty.call(frontmatter, "status");
+        const rawStatus = hasExplicitStatus ? frontmatter.status : undefined;
+        const mappedStatus = mapStatus(rawStatus, hasExplicitStatus);
+        if (mappedStatus.skip) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.habit_migration_skip",
+                message: "skipping done habit",
+                meta: { file, status: rawStatus },
+            });
+            continue;
+        }
+        const legacyLastRun = typeof frontmatter.lastRun === "string" && frontmatter.lastRun !== "null"
+            ? frontmatter.lastRun
+            : typeof frontmatter.last_run === "string" && frontmatter.last_run !== "null"
+                ? frontmatter.last_run
+                : null;
+        // Build new frontmatter, stripping task-only fields
+        const newFrontmatter = {};
+        if (typeof frontmatter.title === "string")
+            newFrontmatter.title = frontmatter.title;
+        if (typeof frontmatter.cadence === "string")
+            newFrontmatter.cadence = frontmatter.cadence;
+        newFrontmatter.status = mappedStatus.status;
+        newFrontmatter.created = typeof frontmatter.created === "string" ? frontmatter.created : "null";
+        // Add any other non-task fields from original
+        for (const [key, value] of Object.entries(frontmatter)) {
+            if (TASK_ONLY_FIELDS.has(key))
+                continue;
+            if (key === "lastRun" || key === "last_run")
+                continue;
+            if (key in newFrontmatter)
+                continue;
+            /* v8 ignore next -- dead code: status is caught by `key in newFrontmatter` above since newFrontmatter.status is always set @preserve */
+            if (key === "status")
+                continue; // already mapped
+            newFrontmatter[key] = value;
+        }
+        const rendered = (0, habit_parser_1.renderHabitFile)(newFrontmatter, body);
+        const publication = (0, habit_lifecycle_1.publishNewHabitDefinition)({
+            agentRoot: bundleRoot,
+            habitId: path.basename(slugName, ".md"),
+            bytes: rendered,
+        });
+        if (publication === "exists") {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.habit_migration_skip",
+                message: "habit already exists at target, skipping",
+                meta: { file, targetPath },
+            });
+            continue;
+        }
+        if (legacyLastRun) {
+            (0, habit_runtime_state_1.writeHabitLastRun)(bundleRoot, path.basename(slugName, ".md"), legacyLastRun);
+        }
+        migratedCount++;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_migrated",
+            message: "migrated habit from task system",
+            meta: { from: sourcePath, to: targetPath },
+        });
+    }
+    if (migratedCount > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_migration_complete",
+            message: "habit migration complete",
+            meta: { bundleRoot, count: migratedCount },
+        });
+    }
+}

package/dist/heart/habits/habit-parser.js

@@ -0,0 +1,278 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHabitFrontmatterSyntaxValid = isHabitFrontmatterSyntaxValid;
+exports.createDegradedHabitFile = createDegradedHabitFile;
+exports.parseHabitFile = parseHabitFile;
+exports.renderHabitFile = renderHabitFile;
+const path = __importStar(require("path"));
+const frontmatter_1 = require("../../util/frontmatter");
+const runtime_1 = require("../../nerves/runtime");
+const habit_policy_1 = require("../../rsvp/habit-policy");
+function isHabitStatus(value) {
+    return value === "active" || value === "paused" || value === "cancelled";
+}
+function parseToolsField(raw) {
+    if (raw === undefined || raw === null)
+        return undefined;
+    // YAML dash-list: parseFrontmatter returns unknown[]
+    if (Array.isArray(raw)) {
+        return raw.filter((item) => typeof item === "string");
+    }
+    // Inline bracket format: parseFrontmatter returns string like "[a, b, c]"
+    if (typeof raw === "string" && raw.startsWith("[") && raw.endsWith("]")) {
+        const inner = raw.slice(1, -1);
+        if (inner.trim().length === 0)
+            return [];
+        return inner.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    return undefined;
+}
+function objectRecord(raw) {
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function booleanField(record, key, fallback) {
+    const value = record[key];
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        if (value === "true")
+            return true;
+        if (value === "false")
+            return false;
+    }
+    return fallback;
+}
+function parseStringArray(raw) {
+    if (typeof raw === "string" && raw.startsWith("[") && raw.endsWith("]")) {
+        const inner = raw.slice(1, -1);
+        if (!inner.trim())
+            return [];
+        return inner.split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    return [];
+}
+function parseOrigin(raw) {
+    const record = objectRecord(raw);
+    if (!record)
+        return null;
+    const friendId = stringField(record, "friendId");
+    const channel = stringField(record, "channel");
+    const key = stringField(record, "key");
+    if (!friendId || !channel || !key)
+        return null;
+    return { friendId, channel, key };
+}
+function parseSurface(raw) {
+    const record = objectRecord(raw);
+    return {
+        family: record ? booleanField(record, "family", true) : true,
+        originator: record ? booleanField(record, "originator", true) : true,
+        extra: record ? parseStringArray(record.extra) : [],
+    };
+}
+function parseContinuity(raw) {
+    const record = objectRecord(raw);
+    const mode = record ? record.mode : null;
+    return { mode: mode === "stateful" ? "stateful" : "fresh" };
+}
+function isHabitFrontmatterSyntaxValid(rawFrontmatter) {
+    const lines = rawFrontmatter.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line.trim())
+            continue;
+        const match = /^([A-Za-z0-9_:-]+):\s*(.*)$/.exec(line);
+        if (!match)
+            return false;
+        if (match[2].length > 0)
+            continue;
+        let cursor = index + 1;
+        while (cursor < lines.length && /^\s*-\s+/.test(lines[cursor]))
+            cursor += 1;
+        if (cursor > index + 1) {
+            index = cursor - 1;
+            continue;
+        }
+        while (cursor < lines.length && /^\s+[A-Za-z0-9_:-]+:\s*/.test(lines[cursor]))
+            cursor += 1;
+        index = cursor - 1;
+    }
+    return true;
+}
+function extractFrontmatterAndBody(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        return { kind: "legacy_body", body: content.trim() };
+    }
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1) {
+        return { kind: "degraded", reason: "unterminated_frontmatter", body: content.trim() };
+    }
+    const rawFrontmatter = lines.slice(1, closing).join("\n");
+    const body = lines.slice(closing + 1).join("\n").trim();
+    if (!isHabitFrontmatterSyntaxValid(rawFrontmatter)) {
+        return { kind: "degraded", reason: "malformed_frontmatter", body };
+    }
+    return { kind: "frontmatter", frontmatter: (0, frontmatter_1.parseFrontmatter)(rawFrontmatter), body };
+}
+function createDegradedHabitFile(filePath, degradedReason, body = "", degradedDetail = null) {
+    const stem = path.basename(filePath, ".md");
+    return {
+        name: stem,
+        title: stem,
+        cadence: null,
+        status: "degraded",
+        degradedReason,
+        degradedDetail,
+        lastRun: null,
+        created: null,
+        tools: undefined,
+        origin: null,
+        surface: { family: false, originator: false, extra: [] },
+        continuity: { mode: "fresh" },
+        body: body.trim(),
+    };
+}
+function parseHabitFile(content, filePath) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.habit_parse",
+        component: "daemon",
+        message: "parsing habit file",
+        meta: { filePath },
+    });
+    const stem = path.basename(filePath, ".md");
+    const parsed = extractFrontmatterAndBody(content);
+    if (parsed.kind === "legacy_body") {
+        return {
+            name: stem,
+            title: stem,
+            cadence: null,
+            status: "active",
+            lastRun: null,
+            created: null,
+            tools: undefined,
+            origin: null,
+            surface: { family: true, originator: true, extra: [] },
+            continuity: { mode: "fresh" },
+            body: parsed.body,
+        };
+    }
+    if (parsed.kind === "degraded") {
+        return createDegradedHabitFile(filePath, parsed.reason, parsed.body);
+    }
+    const { frontmatter, body } = parsed;
+    const rawTitle = frontmatter.title;
+    const title = typeof rawTitle === "string" && rawTitle.length > 0 ? rawTitle : stem;
+    const rawCadence = frontmatter.cadence;
+    const cadence = typeof rawCadence === "string" && rawCadence.length > 0 ? rawCadence : null;
+    const rawStatus = frontmatter.status;
+    const status = rawStatus === undefined
+        ? "active"
+        : typeof rawStatus === "string" && isHabitStatus(rawStatus)
+            ? rawStatus
+            : null;
+    if (status === null) {
+        return createDegradedHabitFile(filePath, "invalid_status", body);
+    }
+    const rawLastRun = frontmatter.lastRun ?? frontmatter.last_run;
+    const lastRun = typeof rawLastRun === "string" && rawLastRun.length > 0 ? rawLastRun : null;
+    const rawCreated = frontmatter.created;
+    const created = typeof rawCreated === "string" && rawCreated.length > 0 ? rawCreated : null;
+    let rsvp;
+    try {
+        rsvp = (0, habit_policy_1.parseRsvpHabitMetadata)(frontmatter.rsvp);
+    }
+    catch (error) {
+        const degradedDetail = (0, habit_policy_1.rsvpHabitMetadataErrorDetail)(error);
+        return createDegradedHabitFile(filePath, "invalid_metadata", body, degradedDetail);
+    }
+    const tools = rsvp ? [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS] : parseToolsField(frontmatter.tools);
+    const origin = parseOrigin(frontmatter.origin);
+    const surface = parseSurface(frontmatter.surface);
+    const continuity = parseContinuity(frontmatter.continuity);
+    return {
+        name: stem,
+        title,
+        cadence,
+        status,
+        lastRun,
+        created,
+        tools,
+        ...(rsvp ? { rsvp } : {}),
+        origin,
+        surface,
+        continuity,
+        body,
+    };
+}
+function formatFrontmatterValue(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (Array.isArray(value))
+        return `[${value.join(", ")}]`;
+    return String(value);
+}
+function renderFrontmatterLine(lines, key, value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        lines.push(`${key}:`);
+        for (const [childKey, childValue] of Object.entries(value)) {
+            lines.push(`  ${childKey}: ${formatFrontmatterValue(childValue)}`);
+        }
+        return;
+    }
+    lines.push(`${key}: ${formatFrontmatterValue(value)}`);
+}
+function renderHabitFile(frontmatter, body) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.habit_render",
+        component: "daemon",
+        message: "rendering habit file",
+        meta: {},
+    });
+    const lines = ["---"];
+    for (const key of Object.keys(frontmatter)) {
+        renderFrontmatterLine(lines, key, frontmatter[key]);
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(body.trim());
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/heart/habits/habit-runtime-state.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readHabitLastRun = readHabitLastRun;
+exports.applyHabitRuntimeState = applyHabitRuntimeState;
+exports.writeHabitLastRun = writeHabitLastRun;
+exports.recordHabitRun = recordHabitRun;
+const path = __importStar(require("path"));
+const json_store_1 = require("../../arc/json-store");
+const runtime_1 = require("../../nerves/runtime");
+function habitRuntimeStateDir(agentRoot) {
+    return path.join(agentRoot, "state", "habits");
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function nullableCursor(value) {
+    return isNonEmptyString(value) ? value.trim() : null;
+}
+function readHabitLastRun(agentRoot, habitName) {
+    const record = (0, json_store_1.readJsonFile)(habitRuntimeStateDir(agentRoot), habitName);
+    return isNonEmptyString(record?.lastRun) ? record.lastRun : null;
+}
+function applyHabitRuntimeState(agentRoot, habit) {
+    const runtimeLastRun = readHabitLastRun(agentRoot, habit.name);
+    if (runtimeLastRun === null)
+        return habit;
+    return { ...habit, lastRun: runtimeLastRun };
+}
+function writeHabitLastRun(agentRoot, habitName, lastRun, updatedAt = lastRun, options = {}) {
+    const record = {
+        schemaVersion: 1,
+        name: habitName,
+        lastRun,
+        updatedAt,
+        activeOperationId: nullableCursor(options.activeOperationId),
+        latestRunId: nullableCursor(options.latestRunId),
+        latestReceiptLocator: nullableCursor(options.latestReceiptLocator),
+    };
+    (0, json_store_1.writeJsonFile)(habitRuntimeStateDir(agentRoot), habitName, record);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.habit_runtime_state_write",
+        message: "wrote habit runtime state",
+        meta: {
+            agentRoot,
+            habitName,
+            lastRun,
+            updatedAt,
+            activeOperationId: record.activeOperationId,
+            latestRunId: record.latestRunId,
+            latestReceiptLocator: record.latestReceiptLocator,
+        },
+    });
+}
+function recordHabitRun(agentRoot, habitName, lastRun, options = {}) {
+    writeHabitLastRun(agentRoot, habitName, lastRun, lastRun, options);
+    // Runtime cursor state is the sole authority for lastRun. Definition files
+    // are lifecycle-owned and must never be opportunistically rewritten from a
+    // run-completion path, even for legacy-field cleanup.
+}