@devory/core 0.1.1 → 0.3.1

package/src/factory-environment.ts

@@ -1,103 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-
-export type FactoryRootSource =
-  | "env:DEVORY_FACTORY_ROOT"
-  | "env:FACTORY_ROOT"
-  | "git-walk"
-  | "cwd";
-
-export type FactoryMode = "local" | "hosted";
-
-export interface FactoryPaths {
-  tasksDir: string;
-  runsDir: string;
-  artifactsDir: string;
-  contextFile: string;
-}
-
-export interface FactoryEnvironment {
-  root: string;
-  source: FactoryRootSource;
-  mode: FactoryMode;
-  paths: FactoryPaths;
-}
-
-const FACTORY_MARKER = "FACTORY_CONTEXT.md";
-
-function trimEnv(value: string | undefined): string | null {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed === "" ? null : trimmed;
-}
-
-export function findFactoryContextDir(startDir: string): string | null {
-  let current = path.resolve(startDir);
-
-  while (true) {
-    if (fs.existsSync(path.join(current, FACTORY_MARKER))) {
-      return current;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-
-export function resolveFactoryRoot(startDir = process.cwd()): {
-  root: string;
-  source: FactoryRootSource;
-} {
-  const explicit = trimEnv(process.env.DEVORY_FACTORY_ROOT);
-  if (explicit) {
-    return { root: explicit, source: "env:DEVORY_FACTORY_ROOT" };
-  }
-
-  const legacy = trimEnv(process.env.FACTORY_ROOT);
-  if (legacy) {
-    return { root: legacy, source: "env:FACTORY_ROOT" };
-  }
-
-  const walked = findFactoryContextDir(startDir);
-  if (walked) {
-    return { root: walked, source: "git-walk" };
-  }
-
-  return { root: path.resolve(startDir), source: "cwd" };
-}
-
-export function factoryPaths(root: string): FactoryPaths {
-  return {
-    tasksDir: path.join(root, "tasks"),
-    runsDir: path.join(root, "runs"),
-    artifactsDir: path.join(root, "artifacts"),
-    contextFile: path.join(root, FACTORY_MARKER),
-  };
-}
-
-export function resolveFactoryMode(env: NodeJS.ProcessEnv = process.env): FactoryMode {
-  const explicitMode = trimEnv(env.DEVORY_FACTORY_MODE) ?? trimEnv(env.FACTORY_MODE);
-  if (explicitMode === "hosted") return "hosted";
-  if (explicitMode === "local") return "local";
-
-  if (trimEnv(env.DEVORY_REMOTE_FACTORY_URL) || trimEnv(env.FACTORY_REMOTE_URL)) {
-    return "hosted";
-  }
-
-  return "local";
-}
-
-export function resolveFactoryEnvironment(
-  startDir = process.cwd(),
-  env: NodeJS.ProcessEnv = process.env
-): FactoryEnvironment {
-  const { root, source } = resolveFactoryRoot(startDir);
-  return {
-    root,
-    source,
-    mode: resolveFactoryMode(env),
-    paths: factoryPaths(root),
-  };
-}

package/src/license.ts

@@ -1,152 +0,0 @@
-/**
- * packages/core/src/license.ts
- *
- * Tier detection and Pro feature gating for Devory.
- *
- * Tiers:
- *   Core  — no license key required; default baselines only; custom_rules ignored
- *   Pro   — license key enables custom_rules and baseline overrides
- *
- * Key resolution order:
- *   1. DEVORY_LICENSE_KEY environment variable
- *   2. .devory/license file in the factory root
- *   3. No key found → Core
- *
- * Network verification is stubbed — a real call will be wired once the
- * license service exists. Local validation (format check) runs synchronously
- * so Core tier never blocks on any network call.
- */
-
-import * as fs from "fs";
-import * as path from "path";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type Tier = "core" | "pro";
-
-/** Features gated behind Pro tier. */
-export type ProFeature = "custom_rules" | "baseline_overrides" | "shared_doctrine" | "pr_gates";
-
-export interface LicenseInfo {
-  tier: Tier;
-  /** Raw key value, if one was found */
-  key?: string;
-  /** Where the key was found */
-  source?: "env" | "file";
-  /** True when a key was found but failed local format validation */
-  invalid?: boolean;
-  /** Human-readable explanation of the tier decision */
-  reason: string;
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const ENV_VAR = "DEVORY_LICENSE_KEY";
-const LICENSE_FILE = path.join(".devory", "license");
-
-/**
- * Minimum length for a key to pass local format validation.
- * Keys will follow a `devory_<tier>_<random>` convention once the license
- * service is built; this floor rejects obvious junk values in the meantime.
- */
-const MIN_KEY_LENGTH = 16;
-
-// ---------------------------------------------------------------------------
-// Tier detection
-// ---------------------------------------------------------------------------
-
-/**
- * Detect the current license tier.
- *
- * @param factoryRoot  Absolute path to the factory workspace root.
- *                     When omitted, file-based key detection is skipped.
- */
-export function detectTier(factoryRoot?: string): LicenseInfo {
-  // 1. Environment variable
-  const envKey = process.env[ENV_VAR];
-  if (envKey !== undefined) {
-    return validateKey(envKey.trim(), "env");
-  }
-
-  // 2. .devory/license file
-  if (factoryRoot) {
-    const filePath = path.join(factoryRoot, LICENSE_FILE);
-    if (fs.existsSync(filePath)) {
-      const fileKey = fs.readFileSync(filePath, "utf-8").trim();
-      return validateKey(fileKey, "file");
-    }
-  }
-
-  // 3. No key — Core
-  return {
-    tier: "core",
-    reason: "No license key found — running on Core tier",
-  };
-}
-
-/**
- * Validate a raw key string and return the corresponding LicenseInfo.
- * Currently performs local format validation only.
- * Network verification is a no-op stub until the license service exists.
- */
-function validateKey(key: string, source: "env" | "file"): LicenseInfo {
-  if (!key || key.length < MIN_KEY_LENGTH) {
-    return {
-      tier: "core",
-      key,
-      source,
-      invalid: true,
-      reason: `License key from ${source === "env" ? "DEVORY_LICENSE_KEY" : ".devory/license"} is invalid (must be ≥ ${MIN_KEY_LENGTH} characters) — falling back to Core tier`,
-    };
-  }
-
-  // TODO: when the license service ships, verify the key here (once, cached
-  // locally in .devory/license-cache.json with an expiry timestamp).
-  return {
-    tier: "pro",
-    key,
-    source,
-    reason: `License key found via ${source === "env" ? "DEVORY_LICENSE_KEY" : ".devory/license"} — Pro tier active`,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Feature gating
-// ---------------------------------------------------------------------------
-
-/**
- * Returns true if the given Pro feature is enabled for the current tier.
- * Call this at each Pro feature boundary instead of comparing tier directly.
- */
-export function isFeatureEnabled(feature: ProFeature, info: LicenseInfo): boolean {
-  // All Pro features require Pro tier. Teams features would extend this check.
-  switch (feature) {
-    case "custom_rules":
-    case "baseline_overrides":
-    case "shared_doctrine":
-    case "pr_gates":
-      return info.tier === "pro";
-  }
-}
-
-/**
- * Produce a one-line advisory message shown to Core users when they have a
- * Pro-only field configured. Shown once per command invocation, not per file.
- */
-export function tierGateMessage(feature: ProFeature): string {
-  const featureLabel: Record<ProFeature, string> = {
-    custom_rules: "custom_rules in devory.standards.yml",
-    baseline_overrides: "baseline overrides",
-    shared_doctrine: "shared doctrine",
-    pr_gates: "PR gates",
-  };
-  return (
-    `[devory] ${featureLabel[feature]} requires a Pro license — ` +
-    `set DEVORY_LICENSE_KEY or create .devory/license to upgrade. ` +
-    `This setting will be ignored on Core tier.`
-  );
-}

package/src/parse.test.ts

@@ -1,161 +0,0 @@
-/**
- * @devory/core — parseFrontmatter tests.
- *
- * Run from factory root: tsx --test packages/core/src/parse.test.ts
- */
-
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { parseFrontmatter } from "./parse.js";
-
-// ── Basic parsing ─────────────────────────────────────────────────────────────
-
-describe("parseFrontmatter", () => {
-  test("parses a minimal frontmatter block", () => {
-    const content = `---
-id: factory-001
-title: My Task
-status: backlog
----
-Body text here.`;
-    const { meta, body } = parseFrontmatter(content);
-    assert.equal(meta.id, "factory-001");
-    assert.equal(meta.title, "My Task");
-    assert.equal(meta.status, "backlog");
-    assert.ok(body.includes("Body text here."));
-  });
-
-  test("returns empty meta and full content when no frontmatter delimiter", () => {
-    const content = "No frontmatter here.";
-    const { meta, body } = parseFrontmatter(content);
-    assert.deepEqual(meta, {});
-    assert.equal(body, content);
-  });
-
-  test("returns empty meta when opening delimiter missing", () => {
-    const content = "id: factory-001\n---\nbody";
-    const { meta } = parseFrontmatter(content);
-    assert.deepEqual(meta, {});
-  });
-
-  test("returns empty meta when closing delimiter missing", () => {
-    const content = "---\nid: factory-001\nbody without close";
-    const { meta } = parseFrontmatter(content);
-    assert.deepEqual(meta, {});
-  });
-
-  test("parses string arrays from list items", () => {
-    const content = `---
-depends_on:
-  - factory-001
-  - factory-002
----
-`;
-    const { meta } = parseFrontmatter(content);
-    assert.deepEqual(meta.depends_on, ["factory-001", "factory-002"]);
-  });
-
-  test("parses empty array from empty value", () => {
-    const content = `---
-depends_on:
----
-`;
-    const { meta } = parseFrontmatter(content);
-    assert.deepEqual(meta.depends_on, []);
-  });
-
-  test("parses empty array from [] syntax", () => {
-    const content = `---
-depends_on: []
----
-`;
-    const { meta } = parseFrontmatter(content);
-    assert.deepEqual(meta.depends_on, []);
-  });
-
-  test("body does not include frontmatter", () => {
-    const content = `---
-id: factory-001
----
-## Section
-Content here.`;
-    const { body } = parseFrontmatter(content);
-    assert.ok(!body.includes("id: factory-001"));
-    assert.ok(body.includes("## Section"));
-  });
-
-  test("parses all standard task fields", () => {
-    const content = `---
-id: factory-010
-title: Test Task
-project: ai-dev-factory
-repo: .
-branch: task/factory-010
-type: feature
-priority: high
-status: ready
-agent: fullstack-builder
----
-`;
-    const { meta } = parseFrontmatter(content);
-    assert.equal(meta.id, "factory-010");
-    assert.equal(meta.title, "Test Task");
-    assert.equal(meta.project, "ai-dev-factory");
-    assert.equal(meta.type, "feature");
-    assert.equal(meta.priority, "high");
-    assert.equal(meta.agent, "fullstack-builder");
-  });
-
-  test("parses verification list", () => {
-    const content = `---
-verification:
-  - npm run test
-  - npm run build
----
-`;
-    const { meta } = parseFrontmatter(content);
-    assert.deepEqual(meta.verification, ["npm run test", "npm run build"]);
-  });
-
-  test("handles hyphen-containing keys like depends_on", () => {
-    const content = `---
-bundle-id: epic-auth
----
-`;
-    const { meta } = parseFrontmatter(content);
-    assert.equal(meta["bundle-id"], "epic-auth");
-  });
-
-  test("trims whitespace from scalar values", () => {
-    const content = `---
-title:   My Task
-status:  backlog
----
-`;
-    const { meta } = parseFrontmatter(content);
-    assert.equal(meta.title, "My Task");
-    assert.equal(meta.status, "backlog");
-  });
-
-  test("ignores list items before any key is set", () => {
-    const content = `---
-  - orphaned-item
-id: factory-001
----
-`;
-    const { meta } = parseFrontmatter(content);
-    assert.equal(meta.id, "factory-001");
-  });
-
-  test("empty content returns empty meta and empty body", () => {
-    const { meta, body } = parseFrontmatter("");
-    assert.deepEqual(meta, {});
-    assert.equal(body, "");
-  });
-
-  test("content with only delimiter lines returns empty meta", () => {
-    const content = "---\n---\n";
-    const { meta } = parseFrontmatter(content);
-    assert.deepEqual(meta, {});
-  });
-});

package/src/parse.ts

@@ -1,103 +0,0 @@
-/**
- * @devory/core — shared frontmatter parsing utilities.
- *
- * Pure functions with no external dependencies.
- * Used by workers/lib, scripts, and apps/devory.
- */
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface TaskMeta {
-  id: string;
-  title: string;
-  project: string;
-  repo: string;
-  branch: string;
-  type: string;
-  priority: string;
-  status: string;
-  agent: string;
-  /** Simulated execution outcome written by an agent after doing work. */
-  execution_result?: string;
-  depends_on: string[];
-  files_likely_affected: string[];
-  verification: string[];
-
-  // Planner / parent-task fields (all optional)
-  planner?: boolean;
-  parent_task?: string;
-  lane?: string;
-  repo_area?: string;
-  decomposition_hint?: string;
-  required_capabilities?: string[];
-  preferred_capabilities?: string[];
-  disallowed_models?: string[];
-  preferred_models?: string[];
-  execution_profile?: string;
-  pipeline?: string;
-  context_intensity?: string;
-  quality_priority?: string;
-  speed_priority?: string;
-  max_cost_tier?: string;
-
-  // Bundle / epic fields (all optional)
-  bundle_id?: string;
-  bundle_title?: string;
-  bundle_phase?: string;
-
-  [key: string]: unknown;
-}
-
-export interface ParseResult {
-  meta: Partial<TaskMeta>;
-  body: string;
-}
-
-// ---------------------------------------------------------------------------
-// Frontmatter parser
-// Handles simple YAML: scalar strings and flat string arrays ("- item").
-// Does not depend on any external package.
-// ---------------------------------------------------------------------------
-
-export function parseFrontmatter(content: string): ParseResult {
-  const lines = content.split("\n");
-
-  if (lines[0]?.trim() !== "---") {
-    return { meta: {}, body: content };
-  }
-
-  const closeIdx = lines.indexOf("---", 1);
-  if (closeIdx === -1) {
-    return { meta: {}, body: content };
-  }
-
-  const yamlLines = lines.slice(1, closeIdx);
-  const body = lines.slice(closeIdx + 1).join("\n");
-  const meta: Partial<TaskMeta> = {};
-  let currentKey = "";
-
-  for (const line of yamlLines) {
-    const listMatch = line.match(/^\s+-\s+(.*)/);
-    const kvMatch = line.match(/^([\w_][\w_-]*):\s*(.*)/);
-
-    if (listMatch && currentKey) {
-      const arr = meta[currentKey];
-      if (Array.isArray(arr)) {
-        arr.push(listMatch[1].trim());
-      }
-    } else if (kvMatch) {
-      currentKey = kvMatch[1];
-      const val = kvMatch[2].trim();
-
-      if (val === "" || val === "[]") {
-        (meta as Record<string, unknown>)[currentKey] = [];
-      } else {
-        (meta as Record<string, unknown>)[currentKey] = val;
-      }
-    }
-  }
-
-  return { meta, body };
-}