@looplia/looplia-cli 0.7.0 → 0.7.1

package/dist/chunk-2TWYHMFD.js

@@ -0,0 +1,1148 @@
+#!/usr/bin/env bun
+import {
+  compileRegistry,
+  getCompiledRegistryPath
+} from "./chunk-DN3RSIIJ.js";
+import {
+  BRAND,
+  DIRTY,
+  EMPTY_PATH,
+  INVALID,
+  NEVER,
+  OK,
+  ParseStatus,
+  ZodAny,
+  ZodArray,
+  ZodBigInt,
+  ZodBoolean,
+  ZodBranded,
+  ZodCatch,
+  ZodDate,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodEffects,
+  ZodEnum,
+  ZodError,
+  ZodFirstPartyTypeKind,
+  ZodFunction,
+  ZodIntersection,
+  ZodIssueCode,
+  ZodLazy,
+  ZodLiteral,
+  ZodMap,
+  ZodNaN,
+  ZodNativeEnum,
+  ZodNever,
+  ZodNull,
+  ZodNullable,
+  ZodNumber,
+  ZodObject,
+  ZodOptional,
+  ZodParsedType,
+  ZodPipeline,
+  ZodPromise,
+  ZodReadonly,
+  ZodRecord,
+  ZodSet,
+  ZodString,
+  ZodSymbol,
+  ZodTuple,
+  ZodType,
+  ZodUndefined,
+  ZodUnion,
+  ZodUnknown,
+  ZodVoid,
+  addIssueToContext,
+  anyType,
+  arrayType,
+  bigIntType,
+  booleanType,
+  coerce,
+  custom,
+  dateType,
+  datetimeRegex,
+  discriminatedUnionType,
+  effectsType,
+  en_default,
+  enumType,
+  functionType,
+  getErrorMap,
+  getParsedType,
+  instanceOfType,
+  intersectionType,
+  isAborted,
+  isAsync,
+  isDirty,
+  isValid,
+  late,
+  lazyType,
+  literalType,
+  makeIssue,
+  mapType,
+  nanType,
+  nativeEnumType,
+  neverType,
+  nullType,
+  nullableType,
+  numberType,
+  objectType,
+  objectUtil,
+  oboolean,
+  onumber,
+  optionalType,
+  ostring,
+  pipelineType,
+  preprocessType,
+  promiseType,
+  quotelessJson,
+  recordType,
+  setErrorMap,
+  setType,
+  strictObjectType,
+  stringType,
+  symbolType,
+  tupleType,
+  undefinedType,
+  unionType,
+  unknownType,
+  util,
+  voidType
+} from "./chunk-HSZZVXV5.js";
+import {
+  pathExists
+} from "./chunk-VRBGWKZ6.js";
+import {
+  __export,
+  init_esm_shims
+} from "./chunk-Y55L47HC.js";
+
+// ../../packages/provider/dist/index.js
+init_esm_shims();
+
+// ../../node_modules/zod/v3/external.js
+var external_exports = {};
+__export(external_exports, {
+  BRAND: () => BRAND,
+  DIRTY: () => DIRTY,
+  EMPTY_PATH: () => EMPTY_PATH,
+  INVALID: () => INVALID,
+  NEVER: () => NEVER,
+  OK: () => OK,
+  ParseStatus: () => ParseStatus,
+  Schema: () => ZodType,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBigInt: () => ZodBigInt,
+  ZodBoolean: () => ZodBoolean,
+  ZodBranded: () => ZodBranded,
+  ZodCatch: () => ZodCatch,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodEffects: () => ZodEffects,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNever: () => ZodNever,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodParsedType: () => ZodParsedType,
+  ZodPipeline: () => ZodPipeline,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSchema: () => ZodType,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodSymbol: () => ZodSymbol,
+  ZodTransformer: () => ZodEffects,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  addIssueToContext: () => addIssueToContext,
+  any: () => anyType,
+  array: () => arrayType,
+  bigint: () => bigIntType,
+  boolean: () => booleanType,
+  coerce: () => coerce,
+  custom: () => custom,
+  date: () => dateType,
+  datetimeRegex: () => datetimeRegex,
+  defaultErrorMap: () => en_default,
+  discriminatedUnion: () => discriminatedUnionType,
+  effect: () => effectsType,
+  enum: () => enumType,
+  function: () => functionType,
+  getErrorMap: () => getErrorMap,
+  getParsedType: () => getParsedType,
+  instanceof: () => instanceOfType,
+  intersection: () => intersectionType,
+  isAborted: () => isAborted,
+  isAsync: () => isAsync,
+  isDirty: () => isDirty,
+  isValid: () => isValid,
+  late: () => late,
+  lazy: () => lazyType,
+  literal: () => literalType,
+  makeIssue: () => makeIssue,
+  map: () => mapType,
+  nan: () => nanType,
+  nativeEnum: () => nativeEnumType,
+  never: () => neverType,
+  null: () => nullType,
+  nullable: () => nullableType,
+  number: () => numberType,
+  object: () => objectType,
+  objectUtil: () => objectUtil,
+  oboolean: () => oboolean,
+  onumber: () => onumber,
+  optional: () => optionalType,
+  ostring: () => ostring,
+  pipeline: () => pipelineType,
+  preprocess: () => preprocessType,
+  promise: () => promiseType,
+  quotelessJson: () => quotelessJson,
+  record: () => recordType,
+  set: () => setType,
+  setErrorMap: () => setErrorMap,
+  strictObject: () => strictObjectType,
+  string: () => stringType,
+  symbol: () => symbolType,
+  transformer: () => effectsType,
+  tuple: () => tupleType,
+  undefined: () => undefinedType,
+  union: () => unionType,
+  unknown: () => unknownType,
+  util: () => util,
+  void: () => voidType
+});
+init_esm_shims();
+
+// ../../packages/provider/dist/index.js
+import { exec } from "child_process";
+import { readFile, rm } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+
+// ../../packages/core/dist/index.js
+init_esm_shims();
+
+// ../../node_modules/zod/index.js
+init_esm_shims();
+
+// ../../packages/core/dist/index.js
+var commands = /* @__PURE__ */ new Map();
+function registerCommand(definition) {
+  if (commands.has(definition.name)) {
+    throw new Error(`Command "${definition.name}" is already registered`);
+  }
+  commands.set(definition.name, definition);
+}
+function buildWorkflowPrompt(ctx) {
+  if (!(ctx.workflowName && ctx.workflowDefinition)) {
+    throw new Error(
+      "Workflow context is required (workflowName, workflowDefinition)"
+    );
+  }
+  return `Task: Execute workflow "${ctx.workflowName}" for session: contentItem/${ctx.contentId}
+
+## Workflow Definition
+
+\`\`\`yaml
+${ctx.workflowDefinition}
+\`\`\`
+
+${ctx.workflowInstructions ? `## Custom Instructions
+
+${ctx.workflowInstructions}
+` : ""}
+## Execution Protocol
+
+### Step 1: Read Validation State
+Read \`contentItem/${ctx.contentId}/validation.json\` to understand:
+- What outputs are required
+- Validation criteria for each output
+- Which outputs have already passed validation
+
+If validation.json is missing, the workflow hasn't started properly.
+
+### Step 2: Execute Outputs (Dependency Order)
+
+For each output in the workflow (following dependency order):
+
+1. **Check completion**:
+   - If artifact exists AND validated=true in validation.json \u2192 skip
+
+2. **If incomplete - use Task tool with custom subagent_type**:
+
+   Use the **Task** tool to invoke the agent specified in the workflow definition.
+   The subagent_type MUST match the \`agent\` field exactly from the workflow YAML.
+
+   Example for an output with \`agent: content-analyzer\`:
+   \`\`\`json
+   {
+     "name": "Task",
+     "input": {
+       "subagent_type": "content-analyzer",
+       "description": "Generate summary artifact",
+       "prompt": "Analyze content at contentItem/${ctx.contentId}/content.md and write summary.json"
+     }
+   }
+   \`\`\`
+
+   The subagent will:
+   - Auto-load its configured skills (from .claude/agents/*.md)
+   - Write artifact to \`contentItem/${ctx.contentId}/{artifact}\`
+
+3. **After artifact written - use Skill tool for validation**:
+
+   Use the **Skill** tool to invoke workflow-validator:
+   \`\`\`json
+   {
+     "name": "Skill",
+     "input": { "skill": "workflow-validator" }
+   }
+   \`\`\`
+
+   Then follow the skill's instructions to validate the artifact against criteria.
+
+4. **Handle validation result**:
+   - If passed: Update validation.json \u2192 set \`outputs.{name}.validated = true\`
+   - If failed: Review failed checks, retry subagent with specific feedback
+
+### Step 3: Return Final Output
+
+When the output marked \`final: true\` passes validation:
+1. Read the final artifact JSON
+2. Return it as structured output
+
+## Workspace Structure
+
+- **Content**: \`contentItem/${ctx.contentId}/content.md\`
+- **Validation**: \`contentItem/${ctx.contentId}/validation.json\`
+- **Artifacts**: \`contentItem/${ctx.contentId}/*.json\`
+- **Workflow**: \`workflows/${ctx.workflowName}.md\`
+- **Agents**: \`.claude/agents/*.md\`
+- **Skills**: \`.claude/skills/*/SKILL.md\`
+
+## Important Rules
+
+- **Validate after each step** - Never skip validation
+- **Update validation.json** - Mark outputs validated when passed
+- **Follow dependencies** - Complete required outputs before dependent ones
+- **Retry on failure** - Give subagent specific feedback on validation failures
+- **Return structured JSON** - Final output must match expected schema`;
+}
+var workflowCommand = {
+  name: "workflow",
+  promptTemplate: buildWorkflowPrompt,
+  // Generic object schema - allows any JSON object structure
+  // Must be an object schema (not z.unknown()) to produce valid JSON schema with "type" field
+  outputSchema: external_exports.record(external_exports.string(), external_exports.unknown())
+};
+registerCommand(workflowCommand);
+var RUN_PATTERN = /^agents\/([a-z][a-z0-9-]*)$/;
+function isValidRunFormat(run) {
+  return RUN_PATTERN.test(run);
+}
+var INPUTLESS_CAPABLE_SKILLS = ["search"];
+var ARRAY_PATTERN = /^\[(.*)\]$/;
+var INTEGER_PATTERN = /^\d+$/;
+var NON_SPACE_PATTERN = /\S/;
+var FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+function isSkippableLine(line) {
+  const trimmed = line.trim();
+  return !trimmed || trimmed.startsWith("#");
+}
+function parseKeyValue(trimmed) {
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex === -1) {
+    return null;
+  }
+  return {
+    key: trimmed.slice(0, colonIndex),
+    value: trimmed.slice(colonIndex + 1).trim()
+  };
+}
+function parseArray(value) {
+  const match = value.match(ARRAY_PATTERN);
+  if (match?.[1] !== void 0) {
+    return match[1].split(",").map((s) => s.trim());
+  }
+  return null;
+}
+function parseYamlValue(value) {
+  const array = parseArray(value);
+  if (array) {
+    return array;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (INTEGER_PATTERN.test(value)) {
+    return Number.parseInt(value, 10);
+  }
+  return value;
+}
+function processYamlLine(state, line) {
+  if (isSkippableLine(line)) {
+    return;
+  }
+  const indent = line.search(NON_SPACE_PATTERN);
+  const trimmed = line.trim();
+  if (indent === 0) {
+    processTopLevel(state, trimmed);
+  } else if (indent === 2 && state.currentKey === "skills") {
+    processSkillItem(state, trimmed);
+  } else if (indent === 2 && state.currentKey === "inputs") {
+    processInputItem(state, trimmed);
+  } else if (indent === 2 && state.currentKey === "steps") {
+    processStepItem(state, trimmed);
+  } else if (indent === 4 && state.currentInput) {
+    processInputProperty(state, trimmed);
+  } else if (indent === 4 && state.currentStep) {
+    processStepProperty(state, trimmed);
+  } else if (indent === 6 && state.currentValidate) {
+    processValidateProperty(state, trimmed);
+  }
+}
+function processSkillItem(state, trimmed) {
+  if (trimmed.startsWith("- ")) {
+    const skillName = trimmed.slice(2).trim();
+    if (skillName) {
+      state.skills.push(skillName);
+    }
+  }
+}
+function processTopLevel(state, trimmed) {
+  if (state.currentStep?.id) {
+    state.steps.push(state.currentStep);
+    state.currentStep = null;
+  }
+  if (state.currentInput?.name) {
+    state.inputs.push(state.currentInput);
+    state.currentInput = null;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  state.currentKey = kv.key;
+  if (kv.key !== "steps" && kv.key !== "inputs" && kv.key !== "skills" && kv.value) {
+    state.result[kv.key] = kv.value;
+  }
+  state.currentValidate = null;
+}
+function processInputItem(state, trimmed) {
+  if (trimmed.startsWith("- ")) {
+    if (state.currentInput?.name) {
+      state.inputs.push(state.currentInput);
+    }
+    state.currentInput = {};
+    const firstProp = trimmed.slice(2).trim();
+    const kv = parseKeyValue(firstProp);
+    if (kv) {
+      handleInputProperty(state.currentInput, kv.key, kv.value);
+    }
+  }
+}
+function handleInputProperty(input, key, value) {
+  switch (key) {
+    case "name":
+      input.name = value;
+      break;
+    case "required":
+      input.required = value === "true";
+      break;
+    case "description":
+      input.description = value;
+      break;
+    case "type":
+      if (value === "file" || value === "json") {
+        input.type = value;
+      }
+      break;
+    default:
+      break;
+  }
+}
+function processInputProperty(state, trimmed) {
+  if (!state.currentInput) {
+    return;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  handleInputProperty(state.currentInput, kv.key, kv.value);
+}
+function processStepItem(state, trimmed) {
+  if (trimmed.startsWith("- ")) {
+    if (state.currentStep?.id) {
+      state.steps.push(state.currentStep);
+    }
+    state.currentStep = {};
+    state.currentValidate = null;
+    const firstProp = trimmed.slice(2).trim();
+    const kv = parseKeyValue(firstProp);
+    if (kv) {
+      handleStepProperty(state.currentStep, kv.key, kv.value);
+    }
+  }
+}
+function handleStepProperty(step, key, value) {
+  switch (key) {
+    case "id":
+      step.id = value;
+      break;
+    case "skill":
+      step.skill = value;
+      break;
+    case "mission":
+      step.mission = value;
+      break;
+    case "run":
+      step.run = value;
+      break;
+    case "input": {
+      const arr = parseArray(value);
+      step.input = arr ?? value;
+      break;
+    }
+    case "output":
+      step.output = value;
+      break;
+    case "needs": {
+      const arr = parseArray(value);
+      if (arr) {
+        step.needs = arr;
+      }
+      break;
+    }
+    case "final":
+      step.final = value === "true";
+      break;
+    case "validate": {
+      const validate = {};
+      step.validate = validate;
+      return validate;
+    }
+    default:
+      break;
+  }
+  return null;
+}
+function processStepProperty(state, trimmed) {
+  if (!state.currentStep) {
+    return;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  const validate = handleStepProperty(state.currentStep, kv.key, kv.value);
+  if (validate) {
+    state.currentValidate = validate;
+  }
+}
+function processValidateProperty(state, trimmed) {
+  if (!state.currentValidate) {
+    return;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  state.currentValidate[kv.key] = parseYamlValue(kv.value);
+}
+function parseFrontmatter(content) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) {
+    throw new Error(
+      "Invalid workflow file: missing YAML frontmatter (must start with ---)"
+    );
+  }
+  const yamlContent = match[1] ?? "";
+  const body = match[2] ?? "";
+  const frontmatter = parseSimpleYaml(yamlContent);
+  return { frontmatter, body: body.trim() };
+}
+function parseSimpleYaml(yaml) {
+  const state = {
+    result: {},
+    steps: [],
+    inputs: [],
+    skills: [],
+    currentKey: "",
+    currentStep: null,
+    currentInput: null,
+    currentValidate: null
+  };
+  for (const line of yaml.split("\n")) {
+    processYamlLine(state, line);
+  }
+  if (state.currentInput?.name) {
+    state.inputs.push(state.currentInput);
+  }
+  if (state.currentStep?.id) {
+    state.steps.push(state.currentStep);
+  }
+  if (state.skills.length > 0) {
+    state.result.skills = state.skills;
+  }
+  if (state.inputs.length > 0) {
+    state.result.inputs = state.inputs;
+  }
+  if (state.steps.length > 0) {
+    state.result.steps = state.steps;
+  }
+  return state.result;
+}
+var INPUT_REFERENCE_PATTERN = /\$\{\{\s*inputs\.(\w[\w-]*)\s*\}\}/g;
+function validateInputReferences(input, workflowInputs) {
+  const inputs = Array.isArray(input) ? input : [input];
+  const declaredNames = new Set(
+    workflowInputs.filter((i) => i.name).map((i) => i.name)
+  );
+  for (const inp of inputs) {
+    const matches = inp.matchAll(INPUT_REFERENCE_PATTERN);
+    for (const match of matches) {
+      const referencedName = match[1];
+      if (referencedName && !declaredNames.has(referencedName)) {
+        throw new Error(
+          `Unknown input reference: inputs.${referencedName}. Declared inputs: ${[...declaredNames].join(", ") || "(none)"}`
+        );
+      }
+    }
+  }
+}
+function validateStepExecutionMode(step) {
+  const hasSkill = Boolean(step.skill && step.mission);
+  const hasRun = Boolean(step.run);
+  if (!(hasSkill || hasRun)) {
+    throw new Error(
+      `Step '${step.id}' must have either 'skill' + 'mission' (v0.6.1) or 'run' (v0.6.0 deprecated)`
+    );
+  }
+  if (hasSkill && hasRun) {
+    throw new Error(
+      `Step '${step.id}' cannot have both 'skill' and 'run' - use one or the other`
+    );
+  }
+  if (hasRun && step.run && !isValidRunFormat(step.run)) {
+    throw new Error(
+      `Step '${step.id}' has invalid run format '${step.run}'. Expected 'agents/{name}' where name is lowercase alphanumeric with hyphens.`
+    );
+  }
+}
+function validateStep(step, workflowInputs = []) {
+  if (!step.id) {
+    throw new Error("Each step must have an 'id' field");
+  }
+  validateStepExecutionMode(step);
+  const isInputlessCapable = step.skill && INPUTLESS_CAPABLE_SKILLS.includes(step.skill);
+  if (!(step.input || isInputlessCapable)) {
+    throw new Error(
+      `Step '${step.id}' must have an 'input' field (or use an input-less capable skill like: ${INPUTLESS_CAPABLE_SKILLS.join(", ")})`
+    );
+  }
+  if (Array.isArray(step.input) && step.input.length === 0) {
+    throw new Error(`Step '${step.id}' input array cannot be empty`);
+  }
+  if (step.input && workflowInputs.length > 0) {
+    validateInputReferences(step.input, workflowInputs);
+  }
+  if (!step.output) {
+    throw new Error(`Step '${step.id}' must have an 'output' field`);
+  }
+}
+function parseWorkflow(content) {
+  const { frontmatter, body } = parseFrontmatter(content);
+  if (!frontmatter.name || typeof frontmatter.name !== "string") {
+    throw new Error("Workflow must have a 'name' field");
+  }
+  if (!frontmatter.description || typeof frontmatter.description !== "string") {
+    throw new Error("Workflow must have a 'description' field");
+  }
+  if (!(frontmatter.steps && Array.isArray(frontmatter.steps)) || frontmatter.steps.length === 0) {
+    throw new Error("Workflow must have at least one step defined");
+  }
+  const workflowInputs = Array.isArray(frontmatter.inputs) ? frontmatter.inputs : [];
+  const workflowSkills = Array.isArray(frontmatter.skills) ? frontmatter.skills : [];
+  for (const step of frontmatter.steps) {
+    validateStep(step, workflowInputs);
+  }
+  const inputs = workflowInputs.filter((inp) => inp.name).map((inp) => ({
+    name: inp.name,
+    required: inp.required ?? true,
+    description: inp.description,
+    type: inp.type
+  }));
+  return {
+    definition: {
+      name: frontmatter.name,
+      version: frontmatter.version,
+      description: frontmatter.description,
+      skills: workflowSkills.length > 0 ? workflowSkills : void 0,
+      inputs: inputs.length > 0 ? inputs : void 0,
+      steps: frontmatter.steps
+    },
+    instructions: body
+  };
+}
+function isInputlessWorkflow(definition) {
+  if (definition.inputs?.some((input) => input.required)) {
+    return false;
+  }
+  const firstSteps = definition.steps.filter(
+    (step) => !step.needs || step.needs.length === 0
+  );
+  if (firstSteps.length === 0) {
+    return false;
+  }
+  return firstSteps.every(
+    (step) => step.skill && INPUTLESS_CAPABLE_SKILLS.includes(step.skill)
+  );
+}
+function extractWorkflowSkills(workflow) {
+  if (workflow.definition.skills && workflow.definition.skills.length > 0) {
+    return workflow.definition.skills;
+  }
+  const skills = /* @__PURE__ */ new Set();
+  for (const step of workflow.definition.steps) {
+    if (step.skill) {
+      skills.add(step.skill);
+    }
+  }
+  return [...skills];
+}
+var SourceTypeSchema = external_exports.enum([
+  "rss",
+  "youtube",
+  "podcast",
+  "twitter",
+  "custom"
+]);
+var SourceSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  type: SourceTypeSchema,
+  label: external_exports.string().optional(),
+  url: external_exports.string(),
+  metadata: external_exports.record(external_exports.unknown()).optional()
+});
+var ContentMetadataSchema = external_exports.object({
+  language: external_exports.string().length(2).optional(),
+  durationSeconds: external_exports.number().positive().optional(),
+  author: external_exports.string().optional(),
+  wordCount: external_exports.number().positive().optional()
+}).passthrough();
+var ContentItemSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  source: SourceSchema,
+  title: external_exports.string().min(1),
+  url: external_exports.string(),
+  publishedAt: external_exports.string().optional(),
+  rawText: external_exports.string().min(1),
+  metadata: ContentMetadataSchema
+});
+var ValidationCriteriaSchema = external_exports.object({
+  required_fields: external_exports.array(external_exports.string()).optional(),
+  min_quotes: external_exports.number().int().positive().optional(),
+  min_key_points: external_exports.number().int().positive().optional(),
+  min_outline_sections: external_exports.number().int().positive().optional(),
+  has_hooks: external_exports.boolean().optional()
+}).passthrough();
+var WorkflowInputSchema = external_exports.object({
+  name: external_exports.string().min(1).regex(/^[a-z][a-z0-9-]*$/, "Input name must be kebab-case"),
+  required: external_exports.boolean(),
+  description: external_exports.string().optional(),
+  type: external_exports.enum(["file", "json"]).optional()
+});
+var WorkflowStepSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  skill: external_exports.string().min(1).optional(),
+  mission: external_exports.string().min(1).optional(),
+  run: external_exports.string().min(1).optional(),
+  input: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
+  output: external_exports.string().min(1),
+  needs: external_exports.array(external_exports.string()).optional(),
+  final: external_exports.boolean().optional(),
+  validate: ValidationCriteriaSchema.optional()
+}).refine(
+  (step) => step.skill && step.mission || step.run,
+  "Step must have either 'skill' + 'mission' or 'run'"
+).refine(
+  (step) => !(step.skill && step.run),
+  "Step cannot have both 'skill' and 'run'"
+);
+var WorkflowDefinitionSchema = external_exports.object({
+  name: external_exports.string().min(1),
+  version: external_exports.string().optional(),
+  description: external_exports.string().min(1),
+  inputs: external_exports.array(WorkflowInputSchema).optional(),
+  steps: external_exports.array(WorkflowStepSchema)
+});
+var StepValidationStateSchema = external_exports.object({
+  output: external_exports.string().min(1),
+  validate: ValidationCriteriaSchema.optional(),
+  validated: external_exports.boolean()
+});
+var ValidationManifestSchema = external_exports.object({
+  workflow: external_exports.string().min(1),
+  version: external_exports.string().optional(),
+  sandboxId: external_exports.string().optional(),
+  createdAt: external_exports.string().optional(),
+  steps: external_exports.record(external_exports.string(), StepValidationStateSchema)
+});
+var ValidationCheckSchema = external_exports.object({
+  name: external_exports.string().min(1),
+  passed: external_exports.boolean(),
+  message: external_exports.string()
+});
+var ValidationResultSchema = external_exports.object({
+  passed: external_exports.boolean(),
+  checks: external_exports.array(ValidationCheckSchema)
+});
+var SessionManifestSchema = external_exports.object({
+  version: external_exports.literal(1),
+  contentId: external_exports.string().min(1),
+  pipeline: external_exports.string().min(1),
+  desiredOutput: external_exports.string().min(1),
+  updatedAt: external_exports.string(),
+  steps: external_exports.record(external_exports.string(), external_exports.literal("done"))
+});
+var UserTopicSchema = external_exports.object({
+  topic: external_exports.string().min(1),
+  interestLevel: external_exports.union([
+    external_exports.literal(1),
+    external_exports.literal(2),
+    external_exports.literal(3),
+    external_exports.literal(4),
+    external_exports.literal(5)
+  ])
+});
+var WritingStyleSchema = external_exports.object({
+  tone: external_exports.enum(["beginner", "intermediate", "expert", "mixed"]),
+  targetWordCount: external_exports.number().min(100).max(1e4),
+  voice: external_exports.enum(["first-person", "third-person", "instructional"])
+});
+var UserProfileSchema = external_exports.object({
+  userId: external_exports.string().min(1),
+  topics: external_exports.array(UserTopicSchema),
+  style: WritingStyleSchema,
+  writingSamples: external_exports.array(external_exports.string()).optional()
+});
+function validateUserProfile(data) {
+  const result = UserProfileSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: { message: result.error.message } };
+}
+
+// ../../packages/provider/dist/index.js
+var execAsync = promisify(exec);
+var GITHUB_FULL_PATTERN = /^https?:\/\/github\.com\/([^/]+\/[^/]+)(?:\/tree\/[^/]+\/(.+))?$/;
+var GITHUB_SIMPLE_PATTERN = /^(?:https?:\/\/)?github\.com\/([^/]+\/[^/]+)\/?$/;
+async function loadCompiledRegistry(autoSync = false) {
+  const compiledPath = getCompiledRegistryPath();
+  if (!await pathExists(compiledPath)) {
+    return await compileRegistry();
+  }
+  if (autoSync) {
+    return await compileRegistry();
+  }
+  const content = await readFile(compiledPath, "utf-8");
+  return JSON.parse(content);
+}
+function findSkill(registry, skillName) {
+  return registry.skills.find((s) => s.name === skillName);
+}
+function getInstalledSkills(registry) {
+  return registry.skills.filter((s) => s.installed);
+}
+function getAvailableSkills(registry) {
+  return registry.skills.filter((s) => !s.installed);
+}
+function getSkillsByCategory(registry, category) {
+  return registry.skills.filter((s) => s.category === category);
+}
+function getSkillsBySource(registry, source) {
+  return registry.skills.filter((s) => s.source === source);
+}
+async function installThirdPartySkill(skill, showProgress = false) {
+  if (!skill.gitUrl) {
+    return {
+      skill: skill.name,
+      status: "failed",
+      error: "No git URL available for skill"
+    };
+  }
+  const source = {
+    id: `temp:${skill.name}`,
+    type: "github",
+    url: skill.gitUrl,
+    enabled: true,
+    priority: 0,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const { syncSource: sync } = await import("./sync-MXQ4NJWI-KGAZYCPW.js");
+  const result = await sync(source, {
+    showProgress,
+    skillPath: skill.skillPath
+    // For marketplace skills
+  });
+  const firstPlugin = result.plugins[0];
+  if (firstPlugin) {
+    return firstPlugin;
+  }
+  return {
+    skill: skill.name,
+    status: "failed",
+    error: result.error ?? "Unknown error during installation"
+  };
+}
+async function installSkill(skillName, registry) {
+  const reg = registry ?? await loadCompiledRegistry();
+  const skill = findSkill(reg, skillName);
+  if (!skill) {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: `Skill not found in registry: ${skillName}`
+    };
+  }
+  if (skill.installed) {
+    return {
+      skill: skillName,
+      status: "already_installed",
+      path: skill.installedPath
+    };
+  }
+  if (skill.sourceType === "builtin") {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: "Built-in skill not found in local installation. Run 'looplia init' to reinstall."
+    };
+  }
+  return await installThirdPartySkill(skill);
+}
+async function updateSkill(skillName, registry) {
+  const reg = registry ?? await loadCompiledRegistry();
+  const skill = findSkill(reg, skillName);
+  if (!skill) {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: `Skill not found in registry: ${skillName}`
+    };
+  }
+  if (!(skill.installed && skill.installedPath)) {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: "Skill is not installed"
+    };
+  }
+  if (skill.sourceType === "builtin") {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: "Cannot update built-in skills. Run 'looplia init' to refresh."
+    };
+  }
+  try {
+    const skillsDir = join(skill.installedPath, "..", "..");
+    await execAsync("git pull", { cwd: skillsDir });
+    return {
+      skill: skillName,
+      status: "updated",
+      path: skill.installedPath
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      skill: skillName,
+      status: "failed",
+      error: message
+    };
+  }
+}
+async function ensureWorkflowSkills(workflow, registry) {
+  const reg = registry ?? await loadCompiledRegistry();
+  const requiredSkills = extractWorkflowSkills(workflow);
+  const installed = [];
+  const failed = [];
+  for (const skillName of requiredSkills) {
+    const skill = findSkill(reg, skillName);
+    if (!skill) {
+      failed.push(skillName);
+      continue;
+    }
+    if (skill.installed) {
+      continue;
+    }
+    if (skill.sourceType === "builtin") {
+      failed.push(skillName);
+      continue;
+    }
+    const result = await installThirdPartySkill(skill);
+    if (result.status === "failed") {
+      failed.push(skillName);
+    } else {
+      installed.push(result);
+    }
+  }
+  return {
+    ready: failed.length === 0,
+    installed,
+    failed
+  };
+}
+async function installSkillFromUrl(url, showProgress = false) {
+  const urlParts = parseGitHubUrl(url);
+  if (!urlParts) {
+    return {
+      skill: "unknown",
+      status: "failed",
+      error: `Invalid GitHub URL: ${url}`
+    };
+  }
+  const { repoUrl, skillPath } = urlParts;
+  const source = {
+    id: `url:${url.replace(/[^a-zA-Z0-9]/g, "-")}`,
+    type: "github",
+    url: repoUrl,
+    enabled: true,
+    priority: 0,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const { syncSource: sync } = await import("./sync-MXQ4NJWI-KGAZYCPW.js");
+  const result = await sync(source, {
+    showProgress,
+    skillPath
+  });
+  if (result.status === "synced") {
+    await compileRegistry();
+  }
+  const firstPlugin = result.plugins[0];
+  if (firstPlugin) {
+    return firstPlugin;
+  }
+  return {
+    skill: "unknown",
+    status: "failed",
+    error: result.error ?? "Unknown error during installation"
+  };
+}
+function parseGitHubUrl(url) {
+  const match = url.match(GITHUB_FULL_PATTERN);
+  if (!match) {
+    const simpleMatch = url.match(GITHUB_SIMPLE_PATTERN);
+    if (simpleMatch?.[1]) {
+      return { repoUrl: `https://github.com/${simpleMatch[1]}.git` };
+    }
+    return null;
+  }
+  const repo = match[1];
+  const path = match[2];
+  return {
+    repoUrl: `https://github.com/${repo}.git`,
+    skillPath: path
+  };
+}
+async function removeSkill(skillName, registry) {
+  const reg = registry ?? await loadCompiledRegistry();
+  const skill = findSkill(reg, skillName);
+  if (!skill) {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: `Skill not found in registry: ${skillName}`
+    };
+  }
+  if (!skill.installed) {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: "Skill is not installed"
+    };
+  }
+  if (skill.sourceType === "builtin") {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: "Cannot remove built-in skills"
+    };
+  }
+  if (!skill.installedPath) {
+    return {
+      skill: skillName,
+      status: "failed",
+      error: "Skill installation path not found"
+    };
+  }
+  try {
+    const pluginDir = join(skill.installedPath, "..", "..");
+    const loopliaPath = join(homedir(), ".looplia");
+    const pluginsDir = join(loopliaPath, "plugins");
+    if (!pluginDir.startsWith(pluginsDir)) {
+      return {
+        skill: skillName,
+        status: "failed",
+        error: "Cannot remove: path is outside plugins directory"
+      };
+    }
+    await rm(pluginDir, { recursive: true, force: true });
+    await compileRegistry();
+    return {
+      skill: skillName,
+      status: "removed",
+      path: pluginDir
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      skill: skillName,
+      status: "failed",
+      error: message
+    };
+  }
+}
+
+export {
+  parseWorkflow,
+  isInputlessWorkflow,
+  extractWorkflowSkills,
+  validateUserProfile,
+  loadCompiledRegistry,
+  findSkill,
+  getInstalledSkills,
+  getAvailableSkills,
+  getSkillsByCategory,
+  getSkillsBySource,
+  installSkill,
+  updateSkill,
+  ensureWorkflowSkills,
+  installSkillFromUrl,
+  removeSkill
+};