@framers/agentos-ext-ml-classifiers 0.1.0 → 0.3.1

package/dist/types.js

@@ -1,62 +1,16 @@
 /**
- * @fileoverview Core type definitions for the ML Classifier Guardrail Extension Pack.
+ * @file types.ts
+ * @description Core type definitions for the ML Classifiers extension pack.
  *
- * This file defines all configuration shapes, runtime result types, and
- * service-identifier constants used by the ML classifier pipeline. All
- * classifiers in this pack evaluate text content against learned models
- * (toxicity, prompt-injection, jailbreak) and emit structured results that
- * feed into the AgentOS guardrail decision tree.
+ * Defines the shared interfaces used across the ML classification system:
+ * classifier categories, confidence results, option shapes, and the LLM
+ * invoker callback signature.
  *
- * Import hierarchy
- * ----------------
- * ```
- * IUtilityAI  ──── ClassificationResult, ClassificationScore
- * IGuardrailService ── GuardrailAction
- *                   │
- *                   ▼
- *              types.ts  (this file)
- *                   │
- *                   ▼
- *           IContentClassifier.ts  /  SlidingWindowBuffer.ts  /  …
- * ```
- *
- * @module agentos/extensions/packs/ml-classifiers/types
- */
-/**
- * Sensible defaults for {@link ClassifierThresholds}.
- *
- * These values reflect a conservative-but-pragmatic policy:
- * - block at 90 % confidence → very high bar, minimises false positives
- * - flag at 70 % → surfaced for human review, not blocked
- * - warn at 40 % → low-confidence signal, handled with a light touch
+ * @module ml-classifiers/types
  */
-export const DEFAULT_THRESHOLDS = {
-    blockThreshold: 0.9,
-    flagThreshold: 0.7,
-    warnThreshold: 0.4,
-};
-// ---------------------------------------------------------------------------
-// Service identifiers
-// ---------------------------------------------------------------------------
 /**
- * Well-known service identifier strings for the three built-in ML classifier
- * pipelines.
- *
- * These IDs follow the `agentos:<domain>:<name>` naming convention used
- * throughout the AgentOS extension ecosystem.  Use them to retrieve specific
- * classifier services from the shared service registry.
- *
- * @example
- * ```typescript
- * const toxicity = serviceRegistry.get(ML_CLASSIFIER_SERVICE_IDS.TOXICITY_PIPELINE);
- * ```
+ * All supported classifier categories as a constant array, used for
+ * iteration and default configuration.
  */
-export const ML_CLASSIFIER_SERVICE_IDS = {
-    /** Classifier that detects toxic, hateful, or abusive language. */
-    TOXICITY_PIPELINE: 'agentos:ml-classifiers:toxicity-pipeline',
-    /** Classifier that detects prompt-injection attempts. */
-    INJECTION_PIPELINE: 'agentos:ml-classifiers:injection-pipeline',
-    /** Classifier that detects jailbreak / system-override attempts. */
-    JAILBREAK_PIPELINE: 'agentos:ml-classifiers:jailbreak-pipeline',
-};
+export const ALL_CATEGORIES = ['toxic', 'injection', 'nsfw', 'threat'];
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AA2CH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAyB;IACtD,cAAc,EAAE,GAAG;IACnB,aAAa,EAAE,GAAG;IAClB,aAAa,EAAE,GAAG;CACV,CAAC;AA6NX,8EAA8E;AAC9E,sBAAsB;AACtB,8EAA8E;AAE9E;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,mEAAmE;IACnE,iBAAiB,EAAE,0CAA0C;IAE7D,yDAAyD;IACzD,kBAAkB,EAAE,2CAA2C;IAE/D,oEAAoE;IACpE,kBAAkB,EAAE,2CAA2C;CACvD,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAgBH;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAyB,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@framers/agentos-ext-ml-classifiers",
-  "version": "0.1.0",
-  "description": "ML-based content classification guardrail (toxicity, injection, jailbreak) for AgentOS",
+  "version": "0.3.1",
+  "description": "ML-based content classifiers for AgentOS — toxicity, prompt injection, and NSFW detection via ONNX models or LLM fallback",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -11,35 +11,21 @@
       "types": "./dist/index.d.ts"
     }
   },
-  "files": [
-    "dist",
-    "src",
-    "SKILL.md",
-    "manifest.json"
-  ],
   "peerDependencies": {
-    "@framers/agentos": "^0.1.0"
+    "@framers/agentos": ">=0.7.0"
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^3.0.0"
   },
+  "license": "Apache-2.0",
   "devDependencies": {
-    "typescript": "^5.5.0",
-    "vitest": "^1.6.0",
-    "@framers/agentos": "0.1.47"
-  },
-  "license": "MIT",
-  "author": "Frame.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/framersai/agentos-extensions.git",
-    "directory": "registry/curated/safety/ml-classifiers"
-  },
-  "publishConfig": {
-    "access": "public"
+    "semantic-release": "^24.0.0",
+    "@semantic-release/github": "^11.0.0"
   },
+  "homepage": "https://agentos.sh",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run"
+    "build": "tsc && node scripts/fix-esm-imports.mjs",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
   }
 }

package/scripts/fix-esm-imports.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const distDir = path.resolve(__dirname, '..', 'dist');
+const SELF_PACKAGE_NAME = '@framers/agentos-ext-ml-classifiers';
+
+function collectJsFiles(dirPath) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectJsFiles(fullPath));
+    } else if (entry.isFile() && fullPath.endsWith('.js')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function resolveSpecifier(filePath, specifier) {
+  if (specifier === SELF_PACKAGE_NAME || specifier.startsWith(`${SELF_PACKAGE_NAME}/`)) {
+    const relativeExportPath =
+      specifier === SELF_PACKAGE_NAME ? 'index' : specifier.slice(SELF_PACKAGE_NAME.length + 1);
+    const targetCandidates = [
+      path.resolve(distDir, `${relativeExportPath}.js`),
+      path.resolve(distDir, relativeExportPath, 'index.js'),
+    ];
+    const targetPath = targetCandidates.find((candidate) => fs.existsSync(candidate));
+    if (!targetPath) {
+      return specifier;
+    }
+
+    let relativePath = path.relative(path.dirname(filePath), targetPath).replace(/\\/g, '/');
+    if (!relativePath.startsWith('.')) {
+      relativePath = `./${relativePath}`;
+    }
+    return relativePath;
+  }
+
+  if (!specifier.startsWith('.')) {
+    return specifier;
+  }
+
+  const hasKnownExtension = /\.(?:[cm]?js|json|node)$/i.test(specifier);
+  if (hasKnownExtension) {
+    return specifier;
+  }
+
+  const baseDir = path.dirname(filePath);
+  const asJs = path.resolve(baseDir, `${specifier}.js`);
+  if (fs.existsSync(asJs)) {
+    return `${specifier}.js`;
+  }
+
+  const asIndex = path.resolve(baseDir, specifier, 'index.js');
+  if (fs.existsSync(asIndex)) {
+    return `${specifier}/index.js`;
+  }
+
+  return specifier;
+}
+
+function rewriteSpecifiers(filePath) {
+  const original = fs.readFileSync(filePath, 'utf8');
+  let modified = original;
+  let changed = false;
+
+  const patterns = [
+    // Multi-line aware: `[\s\S]*?` matches anything including newlines, non-greedy, so
+    // imports with destructuring across multiple lines (e.g. `import { A,\n B\n} from './X'`)
+    // are caught. Anchored to start-of-line by `^` + `m` flag and terminated by the `from`
+    // keyword before a quote.
+    /(^\s*(?:import|export)\s[\s\S]*?from\s+['"])([^'"]+)(['"])/gm,
+    /(import\(\s*['"])([^'"]+)(['"]\s*\))/g
+  ];
+
+  for (const pattern of patterns) {
+    modified = modified.replace(pattern, (match, prefix, specifier, suffix) => {
+      const rewritten = resolveSpecifier(filePath, specifier);
+      if (rewritten !== specifier) {
+        changed = true;
+        return `${prefix}${rewritten}${suffix}`;
+      }
+      return match;
+    });
+  }
+
+  if (changed) {
+    fs.writeFileSync(filePath, modified, 'utf8');
+  }
+}
+
+function copyIfPresent(sourcePath, targetPath) {
+  if (!fs.existsSync(sourcePath)) {
+    return false;
+  }
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+  return true;
+}
+
+/**
+ * Walk the dist tree after rewriting and verify every static/dynamic relative
+ * import has a resolvable extension. Catches the case where a previous build
+ * left partial dist state (e.g. rimraf failed because another process held
+ * files open) and the rewriter's regex didn't reach a stale file.
+ *
+ * Returns an array of {file, specifier, line} for each unfixed import.
+ */
+export function findUnfixedRelativeImports(distDir) {
+  const issues = [];
+  const jsFiles = collectJsFiles(distDir);
+  const patterns = [
+    /(^\s*(?:import|export)\s[\s\S]*?from\s+['"])([^'"]+)(['"])/gm,
+    /(import\(\s*['"])([^'"]+)(['"]\s*\))/g,
+  ];
+  for (const file of jsFiles) {
+    const contents = fs.readFileSync(file, 'utf8');
+    for (const pattern of patterns) {
+      pattern.lastIndex = 0;
+      let m;
+      while ((m = pattern.exec(contents)) !== null) {
+        const specifier = m[2];
+        if (!specifier.startsWith('.')) continue;
+        if (/\.(?:[cm]?js|json|node)$/i.test(specifier)) continue;
+        // Look up the file's line number for a useful error message.
+        const lineNumber = contents.slice(0, m.index).split('\n').length;
+        issues.push({ file, specifier, line: lineNumber });
+      }
+    }
+  }
+  return issues;
+}
+
+// Only run the main pipeline when invoked directly, not when this module is
+// imported from a test or another script.
+if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
+  if (!fs.existsSync(distDir)) {
+    console.log('[agentos fix-esm-imports] dist directory missing; nothing to do.');
+    process.exit(0);
+  }
+
+  const jsFiles = collectJsFiles(distDir);
+  for (const file of jsFiles) {
+    rewriteSpecifiers(file);
+  }
+
+  const copiedExtensionSecrets = copyIfPresent(
+    path.resolve(distDir, 'core', 'config', 'extension-secrets.json'),
+    path.resolve(distDir, 'config', 'extension-secrets.json'),
+  );
+
+  console.log(`[agentos fix-esm-imports] Processed ${jsFiles.length} files under ${distDir}.`);
+  if (copiedExtensionSecrets) {
+    console.log('[agentos fix-esm-imports] Mirrored extension-secrets.json into dist/config for public package exports.');
+  }
+
+  const unfixed = findUnfixedRelativeImports(distDir);
+  if (unfixed.length > 0) {
+    console.error(
+      `[agentos fix-esm-imports] FAIL: ${unfixed.length} relative import${unfixed.length === 1 ? '' : 's'} ` +
+      `in dist still missing a file extension. This usually means a previous build ` +
+      `left partial state — try \`rm -rf dist && pnpm build\`.`,
+    );
+    for (const issue of unfixed.slice(0, 20)) {
+      const rel = path.relative(distDir, issue.file);
+      console.error(`  ${rel}:${issue.line}  ->  ${issue.specifier}`);
+    }
+    if (unfixed.length > 20) {
+      console.error(`  …and ${unfixed.length - 20} more.`);
+    }
+    process.exit(1);
+  }
+}