@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.550

package/dist/repertoire/tasks/scanner.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTaskRoot = getTaskRoot;
 exports.ensureTaskLayout = ensureTaskLayout;
+exports.tryExtractFrontmatter = tryExtractFrontmatter;
 exports.clearTaskScanCache = clearTaskScanCache;
 exports.scanTasks = scanTasks;
 const fs = __importStar(require("fs"));
@@ -59,30 +60,57 @@ function ensureTaskLayout(root = getTaskRoot()) {
         fs.mkdirSync(dir, { recursive: true });
     }
 }
-function walkMarkdownFiles(dir, acc) {
-    if (!fs.existsSync(dir))
-        return;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            if (transitions_1.TASK_RESERVED_DIRECTORIES.includes(entry.name)) {
+/**
+ * Attempt to extract frontmatter from markdown content.
+ * Returns parsed frontmatter dict or null. Never throws.
+ */
+function tryExtractFrontmatter(content) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.frontmatter_extract_start",
+        component: "repertoire",
+        message: "attempting frontmatter extraction",
+    });
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        return null;
+    }
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1) {
+        return null;
+    }
+    const rawFrontmatter = lines.slice(1, closing).join("\n");
+    return (0, parser_1.parseFrontmatter)(rawFrontmatter);
+}
+const LEGACY_TASK_TYPES = ["one-shot", "ongoing", "habit"];
+function buildFingerprint(root) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.fingerprint_build_start",
+        component: "repertoire",
+        message: "building scan fingerprint",
+        meta: { root },
+    });
+    const segments = [];
+    for (const collection of transitions_1.TASK_CANONICAL_COLLECTIONS) {
+        const collDir = path.join(root, collection);
+        const entries = fs.readdirSync(collDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".md"))
                 continue;
-            }
-            walkMarkdownFiles(path.join(dir, entry.name), acc);
-            continue;
-        }
-        if (entry.name.endsWith(".md")) {
-            acc.push(path.join(dir, entry.name));
+            const filePath = path.join(collDir, entry.name);
+            const stat = fs.statSync(filePath);
+            segments.push(`${filePath}:${stat.mtimeMs}:${stat.size}`);
         }
     }
-}
-function buildFingerprint(paths) {
-    const segments = paths
-        .map((filePath) => {
+    // Also include root-level md files for orphan detection fingerprinting
+    const rootEntries = fs.readdirSync(root, { withFileTypes: true });
+    for (const entry of rootEntries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md"))
+            continue;
+        const filePath = path.join(root, entry.name);
         const stat = fs.statSync(filePath);
-        return `${filePath}:${stat.mtimeMs}:${stat.size}`;
-    })
-        .sort();
+        segments.push(`${filePath}:${stat.mtimeMs}:${stat.size}`);
+    }
+    segments.sort();
     return segments.join("|");
 }
 function clearTaskScanCache() {
@@ -96,35 +124,164 @@ function scanTasks(root = getTaskRoot()) {
         meta: { root },
     });
     ensureTaskLayout(root);
-    const files = [];
-    for (const collection of transitions_1.TASK_CANONICAL_COLLECTIONS) {
-        walkMarkdownFiles(path.join(root, collection), files);
-    }
-    const fingerprint = buildFingerprint(files);
+    const fingerprint = buildFingerprint(root);
     if (scanCache && scanCache.fingerprint === fingerprint) {
         return scanCache.index;
     }
     const tasks = [];
-    const parseErrors = [];
-    const invalidFilenames = [];
-    for (const filePath of files) {
-        const base = path.basename(filePath);
-        if (!(0, transitions_1.isCanonicalTaskFilename)(base)) {
-            invalidFilenames.push(filePath);
+    const issues = [];
+    // Scan each collection with flat directory reads (no recursion)
+    for (const collection of transitions_1.TASK_CANONICAL_COLLECTIONS) {
+        const collDir = path.join(root, collection);
+        const entries = fs.readdirSync(collDir, { withFileTypes: true });
+        const dirNames = new Set();
+        // Collect directory names for work dir detection
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                dirNames.add(entry.name);
+            }
         }
-        try {
+        // Process only .md files at collection root (flat, no recursion)
+        let supportDocCount = 0;
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".md"))
+                continue;
+            const filePath = path.join(collDir, entry.name);
             const content = fs.readFileSync(filePath, "utf-8");
-            tasks.push((0, parser_1.parseTaskFile)(content, filePath));
+            // Step 1: Try to extract frontmatter
+            const frontmatter = tryExtractFrontmatter(content);
+            if (!frontmatter) {
+                // No frontmatter — not a task, count as support doc clutter
+                supportDocCount += 1;
+                continue;
+            }
+            // Step 2: Check kind: task
+            const isKindTask = frontmatter.kind === "task";
+            const fmType = typeof frontmatter.type === "string" ? frontmatter.type.trim().toLowerCase() : "";
+            const isLegacyTask = !isKindTask && LEGACY_TASK_TYPES.includes(fmType);
+            if (!isKindTask && !isLegacyTask) {
+                // Has frontmatter but not a task — skip silently
+                continue;
+            }
+            // Step 3: Emit migration issue for legacy task
+            if (isLegacyTask) {
+                const relPath = path.relative(root, filePath);
+                issues.push({
+                    target: relPath,
+                    code: "schema-missing-kind",
+                    description: "Task card missing kind: task field",
+                    fix: "Add kind: task to frontmatter",
+                    confidence: "safe",
+                    category: "migration",
+                });
+            }
+            // Step 4: Parse the task file
+            try {
+                const task = (0, parser_1.parseTaskFile)(content, filePath);
+                // Check filename canonicality
+                const base = path.basename(filePath);
+                if (!(0, transitions_1.isCanonicalTaskFilename)(base)) {
+                    const relPath = path.relative(root, filePath);
+                    issues.push({
+                        target: relPath,
+                        code: "filename-not-canonical",
+                        description: `Non-canonical filename: ${base}`,
+                        fix: `Rename to canonical format (YYYY-MM-DD-HHMM-slug.md)`,
+                        confidence: "safe",
+                        category: "migration",
+                    });
+                }
+                // Work dir detection
+                const stem = base.replace(/\.md$/i, "");
+                if (dirNames.has(stem)) {
+                    task.hasWorkDir = true;
+                    const workDirPath = path.join(collDir, stem);
+                    task.workDirFiles = fs.readdirSync(workDirPath).sort();
+                }
+                tasks.push(task);
+            }
+            catch (error) {
+                // Parse error on a file we identified as a task — real issue
+                const relPath = path.relative(root, filePath);
+                issues.push({
+                    target: relPath,
+                    code: "schema-invalid",
+                    description: `Parse error: ${error instanceof Error ? error.message : String(error)}`,
+                    fix: "Fix the task card schema (ensure required fields: type, status, etc.)",
+                    confidence: "needs_review",
+                    category: "live",
+                });
+            }
+        }
+        // Summarize non-task support docs at collection root as one migration issue
+        if (supportDocCount > 0) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.support_docs_detected",
+                component: "repertoire",
+                message: "non-task support documents at collection root",
+                meta: { collection, count: supportDocCount },
+            });
+            issues.push({
+                target: collection,
+                code: "org-collection-root-clutter",
+                description: `${supportDocCount} non-task file${supportDocCount === 1 ? "" : "s"} at ${collection}/ root (doing docs, planning docs, etc.)`,
+                fix: "Move support docs into same-stem work directories for their parent tasks",
+                confidence: "needs_review",
+                category: "migration",
+            });
+        }
+    }
+    // Orphan detection: root-level .md files outside any canonical collection
+    const rootEntries = fs.readdirSync(root, { withFileTypes: true });
+    const collectionSet = new Set(transitions_1.TASK_CANONICAL_COLLECTIONS);
+    for (const entry of rootEntries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md"))
+            continue;
+        const filePath = path.join(root, entry.name);
+        const content = fs.readFileSync(filePath, "utf-8");
+        const frontmatter = tryExtractFrontmatter(content);
+        // Only flag as orphan if it has task-like frontmatter
+        if (!frontmatter)
+            continue;
+        const fmType = typeof frontmatter.type === "string" ? frontmatter.type.trim().toLowerCase() : "";
+        const hasTaskLikeContent = frontmatter.kind === "task" ||
+            LEGACY_TASK_TYPES.includes(fmType) ||
+            (typeof frontmatter.status === "string" && typeof frontmatter.title === "string");
+        if (hasTaskLikeContent) {
+            (0, runtime_1.emitNervesEvent)({
+                event: "repertoire.orphan_detected",
+                component: "repertoire",
+                message: "root-level orphan document detected",
+                meta: { filePath },
+            });
+            issues.push({
+                target: entry.name,
+                code: "org-root-level-doc",
+                description: `Root-level document outside any collection: ${entry.name}`,
+                fix: `Move to appropriate collection directory (${[...collectionSet].join(", ")})`,
+                confidence: "needs_review",
+                category: "migration",
+            });
         }
-        catch (error) {
-            parseErrors.push(`${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Populate derivedChildren from parent_task links
+    const stemToTask = new Map();
+    for (const task of tasks) {
+        stemToTask.set(task.stem, task);
+    }
+    for (const task of tasks) {
+        const parentStem = typeof task.frontmatter.parent_task === "string"
+            ? task.frontmatter.parent_task.trim()
+            : "";
+        if (parentStem && stemToTask.has(parentStem)) {
+            const parent = stemToTask.get(parentStem);
+            parent.derivedChildren.push(task.stem);
         }
     }
     const index = {
         root,
         tasks,
-        invalidFilenames,
-        parseErrors,
+        issues,
         fingerprint,
     };
     scanCache = { fingerprint, index };

package/dist/repertoire/tasks/transitions.js

@@ -1,50 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TASK_REQUIRED_TEMPLATE_FIELDS = exports.TASK_FILENAME_PATTERN = exports.TASK_RESERVED_DIRECTORIES = exports.TASK_TYPE_TO_COLLECTION = exports.TASK_CANONICAL_COLLECTIONS = exports.TASK_CANONICAL_TYPES = exports.TASK_STATUS_TRANSITIONS = exports.TASK_VALID_STATUSES = void 0;
+exports.TASK_REQUIRED_TEMPLATE_FIELDS = exports.TASK_FILENAME_PATTERN = exports.TASK_RESERVED_DIRECTORIES = exports.TASK_TYPE_TO_COLLECTION = exports.TASK_CANONICAL_COLLECTIONS = exports.TASK_CANONICAL_TYPES = exports.validateTransition = exports.renderTaskTransitionLines = exports.normalizeTaskStatus = exports.isTaskStatus = exports.TASK_VALID_STATUSES = exports.TASK_STATUS_TRANSITIONS = void 0;
 exports.canonicalCollectionForTaskType = canonicalCollectionForTaskType;
 exports.normalizeTaskType = normalizeTaskType;
-exports.normalizeTaskStatus = normalizeTaskStatus;
 exports.isCanonicalTaskFilename = isCanonicalTaskFilename;
-exports.validateTransition = validateTransition;
-exports.renderTaskTransitionLines = renderTaskTransitionLines;
 const runtime_1 = require("../../nerves/runtime");
-exports.TASK_VALID_STATUSES = [
-    "drafting",
-    "processing",
-    "validating",
-    "collaborating",
-    "paused",
-    "blocked",
-    "done",
-];
-exports.TASK_STATUS_TRANSITIONS = {
-    drafting: ["processing", "collaborating"],
-    processing: ["validating", "paused", "blocked"],
-    validating: ["done", "processing", "collaborating"],
-    collaborating: ["processing", "validating", "paused"],
-    paused: ["processing", "blocked"],
-    blocked: ["processing", "paused"],
-    done: [],
-};
+var task_lifecycle_1 = require("../../arc/task-lifecycle");
+Object.defineProperty(exports, "TASK_STATUS_TRANSITIONS", { enumerable: true, get: function () { return task_lifecycle_1.TASK_STATUS_TRANSITIONS; } });
+Object.defineProperty(exports, "TASK_VALID_STATUSES", { enumerable: true, get: function () { return task_lifecycle_1.TASK_VALID_STATUSES; } });
+Object.defineProperty(exports, "isTaskStatus", { enumerable: true, get: function () { return task_lifecycle_1.isTaskStatus; } });
+Object.defineProperty(exports, "normalizeTaskStatus", { enumerable: true, get: function () { return task_lifecycle_1.normalizeTaskStatus; } });
+Object.defineProperty(exports, "renderTaskTransitionLines", { enumerable: true, get: function () { return task_lifecycle_1.renderTaskTransitionLines; } });
+Object.defineProperty(exports, "validateTransition", { enumerable: true, get: function () { return task_lifecycle_1.validateTransition; } });
 exports.TASK_CANONICAL_TYPES = [
     "one-shot",
     "ongoing",
-    "habit",
 ];
 exports.TASK_CANONICAL_COLLECTIONS = [
     "one-shots",
     "ongoing",
-    "habits",
 ];
 exports.TASK_TYPE_TO_COLLECTION = {
     "one-shot": "one-shots",
     ongoing: "ongoing",
-    habit: "habits",
 };
 exports.TASK_RESERVED_DIRECTORIES = ["templates", ".trash", "archive"];
 exports.TASK_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}-\d{4}-[a-z0-9][a-z0-9-]*\.md$/;
 exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
     "one-shot": [
+        "kind",
         "type",
         "category",
         "title",
@@ -58,10 +42,10 @@ exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
         "updated",
         "parent_task",
         "depends_on",
-        "child_tasks",
         "artifacts",
     ],
     ongoing: [
+        "kind",
         "type",
         "category",
         "title",
@@ -73,22 +57,6 @@ exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
         "lastRun",
         "created",
         "updated",
-        "child_tasks",
-        "artifacts",
-    ],
-    habit: [
-        "type",
-        "category",
-        "title",
-        "status",
-        "validator",
-        "requester",
-        "cadence",
-        "scheduledAt",
-        "lastRun",
-        "created",
-        "updated",
-        "child_tasks",
         "artifacts",
     ],
 };
@@ -96,6 +64,12 @@ function canonicalCollectionForTaskType(type) {
     return exports.TASK_TYPE_TO_COLLECTION[type];
 }
 function normalizeTaskType(value) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.task_type_normalize",
+        component: "repertoire",
+        message: "normalizing task type",
+        meta: { input: value ?? null },
+    });
     if (typeof value !== "string")
         return null;
     const normalized = value.trim().toLowerCase();
@@ -103,42 +77,6 @@ function normalizeTaskType(value) {
         ? normalized
         : null;
 }
-function normalizeTaskStatus(value) {
-    if (typeof value !== "string")
-        return null;
-    const normalized = value.trim().toLowerCase();
-    return exports.TASK_VALID_STATUSES.includes(normalized)
-        ? normalized
-        : null;
-}
 function isCanonicalTaskFilename(value) {
     return typeof value === "string" && exports.TASK_FILENAME_PATTERN.test(value);
 }
-function validateTransition(from, to) {
-    (0, runtime_1.emitNervesEvent)({
-        event: "mind.step_start",
-        component: "mind",
-        message: "validating task status transition",
-        meta: { from, to },
-    });
-    if (from === to) {
-        return { ok: true, from, to };
-    }
-    const allowed = exports.TASK_STATUS_TRANSITIONS[from];
-    if (!allowed.includes(to)) {
-        return {
-            ok: false,
-            from,
-            to,
-            reason: `invalid transition: ${from} -> ${to}`,
-        };
-    }
-    return { ok: true, from, to };
-}
-function renderTaskTransitionLines() {
-    return exports.TASK_VALID_STATUSES.map((from) => {
-        const to = exports.TASK_STATUS_TRANSITIONS[from];
-        const rendered = to.length > 0 ? to.map((next) => `\`${next}\``).join(", ") : "(terminal)";
-        return `- \`${from}\` -> ${rendered}`;
-    });
-}

package/dist/repertoire/tool-results.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.okToolResult = okToolResult;
+exports.frictionToolResult = frictionToolResult;
+const runtime_1 = require("../nerves/runtime");
+function okToolResult(tool, data) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "tools",
+        event: "tool.structured_ok",
+        message: "tool returned structured result",
+        meta: { tool },
+    });
+    return JSON.stringify({ ok: true, tool, data }, null, 2);
+}
+function frictionToolResult(tool, friction) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "tools",
+        event: "tool.structured_friction",
+        message: "tool returned structured result",
+        meta: {
+            tool,
+            kind: friction.kind,
+            recoverability: friction.recoverability,
+            signature: friction.signature,
+        },
+    });
+    return JSON.stringify({ ok: false, tool, friction }, null, 2);
+}