wtf-p 0.7.4 → 0.8.0

package/vendors/clio-extension/runtime/json-schema.cjs

@@ -0,0 +1,304 @@
+// Generated by WTF-P adapter compiler v5 from evaluation/lib/json-schema.js; do not edit.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function deepEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function valueType(value) {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) return 'array';
+  if (Number.isInteger(value)) return 'integer';
+  return typeof value;
+}
+
+function escapeLocationSegment(segment) {
+  return /^[A-Za-z_$][A-Za-z0-9_$-]*$/.test(segment)
+    ? `.${segment}`
+    : `[${JSON.stringify(segment)}]`;
+}
+
+function calendarDateValid(year, month, day) {
+  if (month < 1 || month > 12 || day < 1) return false;
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return day <= days[month - 1];
+}
+
+function rfc3339DateValid(value) {
+  const match = value.match(/^(\d{4})-(\d{2})-(\d{2})$/u);
+  return Boolean(match && calendarDateValid(Number(match[1]), Number(match[2]), Number(match[3])));
+}
+
+function rfc3339DateTimeValid(value) {
+  const match = value.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|([+-])(\d{2}):(\d{2}))$/u);
+  if (!match || !calendarDateValid(Number(match[1]), Number(match[2]), Number(match[3]))) return false;
+  const hour = Number(match[4]);
+  const minute = Number(match[5]);
+  const second = Number(match[6]);
+  // Leap seconds are intentionally rejected: the evaluator needs deterministic
+  // ordering through JavaScript Date parsing, which does not represent :60.
+  if (hour > 23 || minute > 59 || second > 59) return false;
+  if (match[7] !== 'Z' && (Number(match[9]) > 23 || Number(match[10]) > 59)) return false;
+  return Number.isFinite(Date.parse(value));
+}
+
+function resolvePointer(document, fragment, source) {
+  if (!fragment || fragment === '#') return document;
+  if (!fragment.startsWith('#/')) {
+    throw new Error(`${source}: unsupported JSON Schema fragment ${fragment}`);
+  }
+
+  return decodeURIComponent(fragment.slice(2)).split('/').reduce((value, segment) => {
+    const key = segment.replace(/~1/g, '/').replace(/~0/g, '~');
+    if (!value || !Object.prototype.hasOwnProperty.call(value, key)) {
+      throw new Error(`${source}: unresolved JSON pointer ${fragment}`);
+    }
+    return value[key];
+  }, document);
+}
+
+class SchemaRegistry {
+  constructor(schemaFiles = []) {
+    this.documents = new Map();
+    this.identifiers = new Map();
+    for (const file of schemaFiles) this.add(file);
+  }
+
+  add(file) {
+    const resolved = path.resolve(file);
+    if (this.documents.has(resolved)) return this.documents.get(resolved);
+    const document = readJson(resolved);
+    this.documents.set(resolved, document);
+    if (document.$id) {
+      if (this.identifiers.has(document.$id) && this.identifiers.get(document.$id) !== resolved) {
+        throw new Error(`duplicate JSON Schema identifier ${document.$id}`);
+      }
+      this.identifiers.set(document.$id, resolved);
+    }
+    return document;
+  }
+
+  get(file) {
+    return this.add(file);
+  }
+
+  resolve(reference, currentFile) {
+    const separator = reference.indexOf('#');
+    const resource = separator === -1 ? reference : reference.slice(0, separator);
+    const fragment = separator === -1 ? '' : reference.slice(separator);
+    let targetFile = path.resolve(currentFile);
+
+    if (resource) {
+      if (this.identifiers.has(resource)) {
+        targetFile = this.identifiers.get(resource);
+      } else if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(resource)) {
+        throw new Error(`${currentFile}: unregistered JSON Schema identifier ${resource}`);
+      } else {
+        targetFile = path.resolve(path.dirname(currentFile), resource);
+      }
+    }
+
+    const document = this.get(targetFile);
+    return {
+      file: targetFile,
+      schema: resolvePointer(document, fragment, targetFile)
+    };
+  }
+}
+
+function validateInstance(instance, schema, schemaFile, registry, location = '$') {
+  if (schema === true) return [];
+  if (schema === false) return [`${location}: is rejected by the false schema`];
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+    throw new Error(`${schemaFile}: JSON Schema node at ${location} must be an object or boolean`);
+  }
+
+  const errors = [];
+
+  if (schema.$ref) {
+    const target = registry.resolve(schema.$ref, schemaFile);
+    errors.push(...validateInstance(instance, target.schema, target.file, registry, location));
+  }
+
+  for (const child of schema.allOf || []) {
+    errors.push(...validateInstance(instance, child, schemaFile, registry, location));
+  }
+
+  if (schema.anyOf) {
+    const matches = schema.anyOf.filter(child =>
+      validateInstance(instance, child, schemaFile, registry, location).length === 0
+    ).length;
+    if (matches === 0) errors.push(`${location}: must match at least one anyOf branch`);
+  }
+
+  if (schema.oneOf) {
+    const matches = schema.oneOf.filter(child =>
+      validateInstance(instance, child, schemaFile, registry, location).length === 0
+    ).length;
+    if (matches !== 1) errors.push(`${location}: must match exactly one oneOf branch (matched ${matches})`);
+  }
+
+  if (schema.if) {
+    const conditionMatches = validateInstance(instance, schema.if, schemaFile, registry, location).length === 0;
+    if (conditionMatches && schema.then) {
+      errors.push(...validateInstance(instance, schema.then, schemaFile, registry, location));
+    }
+    if (!conditionMatches && schema.else) {
+      errors.push(...validateInstance(instance, schema.else, schemaFile, registry, location));
+    }
+  }
+
+  if (schema.not && validateInstance(instance, schema.not, schemaFile, registry, location).length === 0) {
+    errors.push(`${location}: must not match the forbidden schema`);
+  }
+
+  if (Object.prototype.hasOwnProperty.call(schema, 'const') && !deepEqual(instance, schema.const)) {
+    errors.push(`${location}: must equal ${JSON.stringify(schema.const)}`);
+  }
+  if (schema.enum && !schema.enum.some(item => deepEqual(instance, item))) {
+    errors.push(`${location}: must be one of ${schema.enum.map(JSON.stringify).join(', ')}`);
+  }
+
+  if (schema.type) {
+    const allowed = Array.isArray(schema.type) ? schema.type : [schema.type];
+    const actual = valueType(instance);
+    const matches = allowed.some(type => type === actual || (type === 'number' && actual === 'integer'));
+    if (!matches) {
+      errors.push(`${location}: expected ${allowed.join('|')}, got ${actual}`);
+      return errors;
+    }
+  }
+
+  if (typeof instance === 'string') {
+    if (schema.minLength !== undefined && instance.length < schema.minLength) {
+      errors.push(`${location}: string is shorter than ${schema.minLength}`);
+    }
+    if (schema.maxLength !== undefined && instance.length > schema.maxLength) {
+      errors.push(`${location}: string is longer than ${schema.maxLength}`);
+    }
+    if (schema.pattern && !new RegExp(schema.pattern, 'u').test(instance)) {
+      errors.push(`${location}: does not match ${schema.pattern}`);
+    }
+    if (schema.format === 'date-time' && !rfc3339DateTimeValid(instance)) {
+      errors.push(`${location}: is not an RFC 3339 date-time`);
+    }
+    if (schema.format === 'date' && !rfc3339DateValid(instance)) {
+      errors.push(`${location}: is not an ISO 8601 date`);
+    }
+    if (schema.format === 'uri') {
+      try {
+        new URL(instance);
+      } catch {
+        errors.push(`${location}: is not an absolute URI`);
+      }
+    }
+  }
+
+  if (typeof instance === 'number') {
+    if (schema.minimum !== undefined && instance < schema.minimum) {
+      errors.push(`${location}: is below ${schema.minimum}`);
+    }
+    if (schema.maximum !== undefined && instance > schema.maximum) {
+      errors.push(`${location}: is above ${schema.maximum}`);
+    }
+    if (schema.exclusiveMinimum !== undefined && instance <= schema.exclusiveMinimum) {
+      errors.push(`${location}: is not greater than ${schema.exclusiveMinimum}`);
+    }
+    if (schema.exclusiveMaximum !== undefined && instance >= schema.exclusiveMaximum) {
+      errors.push(`${location}: is not less than ${schema.exclusiveMaximum}`);
+    }
+  }
+
+  if (Array.isArray(instance)) {
+    if (schema.minItems !== undefined && instance.length < schema.minItems) {
+      errors.push(`${location}: has fewer than ${schema.minItems} items`);
+    }
+    if (schema.maxItems !== undefined && instance.length > schema.maxItems) {
+      errors.push(`${location}: has more than ${schema.maxItems} items`);
+    }
+    if (schema.uniqueItems) {
+      const serialized = instance.map(item => JSON.stringify(item));
+      if (new Set(serialized).size !== serialized.length) {
+        errors.push(`${location}: items are not unique`);
+      }
+    }
+    if (schema.items) {
+      instance.forEach((item, index) => {
+        errors.push(...validateInstance(item, schema.items, schemaFile, registry, `${location}[${index}]`));
+      });
+    }
+  }
+
+  if (instance && typeof instance === 'object' && !Array.isArray(instance)) {
+    const properties = schema.properties || {};
+    const patternProperties = schema.patternProperties || {};
+    const keys = Object.keys(instance);
+    if (schema.minProperties !== undefined && keys.length < schema.minProperties) {
+      errors.push(`${location}: has fewer than ${schema.minProperties} properties`);
+    }
+    if (schema.maxProperties !== undefined && keys.length > schema.maxProperties) {
+      errors.push(`${location}: has more than ${schema.maxProperties} properties`);
+    }
+    for (const required of schema.required || []) {
+      if (!Object.prototype.hasOwnProperty.call(instance, required)) {
+        errors.push(`${location}: missing required property ${required}`);
+      }
+    }
+
+    for (const key of keys) {
+      const matchingPatterns = Object.entries(patternProperties)
+        .filter(([pattern]) => new RegExp(pattern, 'u').test(key));
+      const declared = Object.prototype.hasOwnProperty.call(properties, key);
+      if (!declared && matchingPatterns.length === 0) {
+        if (schema.additionalProperties === false) {
+          errors.push(`${location}: unknown property ${key}`);
+        } else if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+          errors.push(...validateInstance(
+            instance[key],
+            schema.additionalProperties,
+            schemaFile,
+            registry,
+            `${location}${escapeLocationSegment(key)}`
+          ));
+        }
+      }
+      for (const [, childSchema] of matchingPatterns) {
+        errors.push(...validateInstance(
+          instance[key],
+          childSchema,
+          schemaFile,
+          registry,
+          `${location}${escapeLocationSegment(key)}`
+        ));
+      }
+    }
+
+    for (const [key, childSchema] of Object.entries(properties)) {
+      if (Object.prototype.hasOwnProperty.call(instance, key)) {
+        errors.push(...validateInstance(
+          instance[key],
+          childSchema,
+          schemaFile,
+          registry,
+          `${location}${escapeLocationSegment(key)}`
+        ));
+      }
+    }
+  }
+
+  return errors;
+}
+
+module.exports = {
+  SchemaRegistry,
+  readJson,
+  validateInstance
+};

package/vendors/clio-extension/runtime/package.json

@@ -0,0 +1,3 @@
+{
+	"type": "module"
+}

package/vendors/clio-extension/runtime/write-guard.json

@@ -0,0 +1,21 @@
+{
+  "schema": "wtfp.clio-write-guard/v1",
+  "actions": {
+    "execute-outline": [
+      ".planning",
+      "paper"
+    ],
+    "polish-prose": [
+      ".planning",
+      "paper"
+    ],
+    "quick": [
+      ".planning",
+      "paper"
+    ],
+    "write-section": [
+      ".planning",
+      "paper"
+    ]
+  }
+}

package/vendors/clio-extension/skins/wtfp.json

@@ -0,0 +1,20 @@
+{
+	"palette": {
+		"cyanStrong": { "dark": "#f07ce4", "light": "#8c1d82" },
+		"cyanFocal": { "dark": "#ec8a74", "light": "#a63c25" }
+	},
+	"glyphs": { "brand": "✎" },
+	"agents": {
+		"wtfp-outliner": { "label": "Outliner", "glyph": "☰" },
+		"wtfp-section-planner": { "label": "Section planner", "glyph": "◇" },
+		"wtfp-plan-checker": { "label": "Plan checker", "glyph": "◈" },
+		"wtfp-research-synthesizer": { "label": "Research synthesizer", "glyph": "≋" },
+		"wtfp-section-writer": { "label": "Section writer", "glyph": "✎" },
+		"wtfp-section-reviewer": { "label": "Section reviewer", "glyph": "◎" },
+		"wtfp-argument-verifier": { "label": "Argument verifier", "glyph": "∴" },
+		"wtfp-coherence-checker": { "label": "Coherence checker", "glyph": "⇄" },
+		"wtfp-prose-polisher": { "label": "Prose polisher", "glyph": "✦" },
+		"wtfp-citation-expert": { "label": "Citation expert", "glyph": "❝" },
+		"wtfp-citation-formatter": { "label": "Citation formatter", "glyph": "¶" }
+	}
+}

package/vendors/codex/plugins/wtfp/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wtfp",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Evidence-grounded academic research, planning, writing, review, and delivery workflows.",
   "author": {
     "name": "akougkas",

package/vendors/codex/plugins/wtfp/.wtfp-generated.json

@@ -2,11 +2,11 @@
   "schema": "wtfp.generated-adapter/v1",
   "generatorVersion": 5,
   "target": "codex",
-  "sourceHash": "712b27f0d02936d335ce28b78a12c8f7a6293bb4bb1adf7b9dbfd4e44a6ea1a4",
+  "sourceHash": "d0ce91ae7440986c363ee10ffe7eb36561b8ca58cae2bd3a0f6ffd323b6759b7",
   "files": [
     {
       "path": ".codex-plugin/plugin.json",
-      "sha256": "0d1fb778a0d6bb028f69f9d5e3933e2c0fdd5de88e4d6b4b49d2e5609f9346cf"
+      "sha256": "3b27fd09165749cdb099bb0fd835db0e42938908ffda80e718b48a9a4e64f85d"
     },
     {
       "path": "actions/add-todo.json",
@@ -222,7 +222,7 @@
     },
     {
       "path": "plugin.json",
-      "sha256": "dab679d955f5fcd044534296f249d0bc4aac481526f7d32d67faa690b7c1ee25"
+      "sha256": "c3717895f13793a547a61373c41095853d6589b61f98eeee46d77b277d020c4e"
     },
     {
       "path": "project/README.md",

package/vendors/codex/plugins/wtfp/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "wtfp",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Portable, evidence-grounded academic research and writing workflows.",
   "author": {
     "name": "akougkas"

package/vendors/copilot/.wtfp-generated.json

@@ -2,11 +2,11 @@
   "schema": "wtfp.generated-adapter/v1",
   "generatorVersion": 5,
   "target": "copilot-marketplace",
-  "sourceHash": "b8909d5801b39fe2b366b20559d6c788e777651746cb9568d1c5f4191161d559",
+  "sourceHash": "4ca961caeec3dca222a55ef4e91b298694563f8baea8d24fe4c0a4634c07f868",
   "files": [
     {
       "path": "marketplace.json",
-      "sha256": "acd3e2b5ba33f28881681519ef9f38a800fedf35d8dc5876c9a5d9dd935eaef1"
+      "sha256": "dc1062489823e8ab8561221e13836878333cc7ad3082c08a04316048b7514813"
     },
     {
       "path": "project/.github/agents/wtfp-argument-verifier.agent.md",

package/vendors/copilot/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "WTF-P research workflow plugins",
-    "version": "0.7.4"
+    "version": "0.8.0"
   },
   "plugins": [
     {
       "name": "wtfp",
       "source": "./plugins/wtfp",
       "description": "Portable academic research and writing workflows.",
-      "version": "0.7.4",
+      "version": "0.8.0",
       "author": {
         "name": "akougkas"
       },

package/vendors/copilot/plugins/wtfp/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wtfp",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Portable academic research and writing workflows with stable wtfp actions.",
   "author": {
     "name": "akougkas",

package/vendors/copilot/plugins/wtfp/.wtfp-generated.json

@@ -2,11 +2,11 @@
   "schema": "wtfp.generated-adapter/v1",
   "generatorVersion": 5,
   "target": "copilot",
-  "sourceHash": "e85cc5ad43e482dce276ea024621cf1bca6ba2f5d389dbbc90aa3f8d0efeaa48",
+  "sourceHash": "cfd8e83bbbc037bf1f487a6c4534261bdcab7d2e32f030d232bf00e4a60f815a",
   "files": [
     {
       "path": ".claude-plugin/plugin.json",
-      "sha256": "06d93546610469be4076195c9c4ff95ddde74910ccbbb3f8de0a627677249876"
+      "sha256": "9b8391fc30f1b454b4795cb94c5de6b0ef6fb7accc1546221c3239f2b7ffeaae"
     },
     {
       "path": "actions/add-todo.json",

package/vendors/gemini/.wtfp-generated.json

@@ -2,7 +2,7 @@
   "schema": "wtfp.generated-adapter/v1",
   "generatorVersion": 5,
   "target": "gemini",
-  "sourceHash": "acac03d8c3f845113c74322cf08a094e7782102c73597f0012cbd7ee1433eae8",
+  "sourceHash": "853978c226536b563e078e632ecec210b0246fd33746d3236463e926da147295",
   "files": [
     {
       "path": "actions/add-todo.json",
@@ -362,7 +362,7 @@
     },
     {
       "path": "gemini-extension.json",
-      "sha256": "35f1733ded31dc01c856a88063614d5524cf790e100abac1167d77c048b523c2"
+      "sha256": "90394dff1a58c75ddede1f979458d5ede617bf1ac4b9e4da0cc5fdf0ea780543"
     },
     {
       "path": "GEMINI.md",

package/vendors/gemini/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "wtfp",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Portable academic research and writing workflows for Gemini CLI.",
   "contextFileName": "GEMINI.md"
 }