feat: JavaScript/TypeScript adapter — lh_standard_adapter for npm (#1)

adapters/javascript/README.md

@@ -0,0 +1,27 @@
+# lh-standard-adapter (JS/TS)
+
+LongHun Standard Adapter — v∞ DNA traceability + seven-factor behavioral audit for npm.
+
+## Install
+```bash
+npm install lh-standard-adapter
+```
+
+## Usage
+```js
+import { LongHunAdapter } from 'lh-standard-adapter';
+
+const adapter = new LongHunAdapter({ uid: '9622', device: 'HM-9622-001' });
+const wrapped = adapter.wrap({ code: "console.log('hello')" }, 'code', 'P04-Luban');
+const result = adapter.validate(wrapped);
+console.log(result.summary); // ✅ VALID
+```
+
+## API
+- `new LongHunAdapter(options?)` — uid, device, locale
+- `.wrap(data, taskType?, persona?, action?, version?)` → WrappedPayload
+- `.validate(wrapped)` → ValidationResult
+- `.getSchemas()` → { dnaSchema, auditSchema }
+
+## License
+CC-BY-NC-SA 4.0 — LongHun Core · UID9622

adapters/javascript/index.d.ts

@@ -0,0 +1,41 @@
+declare module 'lh-standard-adapter' {
+  export interface LongHunAdapterOptions { uid?: string; device?: string; locale?: string; }
+  export interface WrappedPayload { dna: string; audit: AuditObject; payload: any; meta: MetaObject; }
+  export interface AuditObject {
+    audit_version: string; uid: string; persona?: string; task_type?: string;
+    behavior_signature: BehaviorSignature; behavior_pattern: string;
+    behavior_labels: string[]; color: string; timestamp: string; payload_hash: string;
+  }
+  export interface BehaviorSignature {
+    P: string; F: string; T: number; E: string; C: number; R: number;
+    A: string; X: string; Y: string; Z: number;
+  }
+  export interface MetaObject {
+    adapter_version: string; uid: string; device: string;
+    task_type: string; persona: string; generated_at: string; format: string;
+  }
+  export interface ValidationResult { valid: boolean; errors: string[]; warnings: string[]; summary: string; }
+  export class DNAGenerator {
+    constructor(uid?: string, device?: string, locale?: string);
+    generate(taskType?: string, action?: string, version?: string | null): string;
+  }
+  export class AuditWrapper {
+    constructor(uid?: string);
+    wrap(payload: any, taskType?: string, persona?: string): AuditObject;
+  }
+  export class Validator {
+    constructor();
+    validate(wrapped: WrappedPayload): ValidationResult;
+  }
+  export class LongHunAdapter {
+    constructor(options?: LongHunAdapterOptions);
+    uid: string; device: string;
+    wrap(data: any, taskType?: string, persona?: string, action?: string, version?: string | null): WrappedPayload;
+    validate(wrapped: WrappedPayload): ValidationResult;
+    getSchemas(): { dnaSchema: any; auditSchema: any };
+  }
+  export function wrap(data: any, taskType?: string, persona?: string, uid?: string, device?: string): WrappedPayload;
+  export function generateDna(taskType?: string, action?: string, version?: string | null): string;
+  export function auditWrap(payload: any, taskType?: string, persona?: string): AuditObject;
+  export function quickValidate(wrapped: WrappedPayload): boolean;
+}

adapters/javascript/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "lh-standard-adapter",
+  "version": "1.0.0",
+  "description": "LongHun Standard Adapter — v∞ DNA traceability + seven-factor behavioral audit for JS/TS",
+  "main": "./src/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./src/index.cjs",
+      "types": "./index.d.ts"
+    }
+  },
+  "type": "module",
+  "files": ["src/", "index.d.ts", "README.md"],
+  "license": "CC-BY-NC-SA-4.0",
+  "engines": {"node": ">=16"},
+  "scripts": {"test": "node test/test.js"}
+}

adapters/javascript/src/audit_wrapper.js

@@ -0,0 +1,66 @@
+/**
+ * Audit Wrapper — seven-factor behavioral audit metadata generation.
+ */
+import crypto from 'crypto';
+
+const LABEL_MAP = {
+  P: {HasPromise:"7F-P-有承诺",NoPromise:"7F-P-无承诺"},
+  F: {Fulfilled:"7F-F-已兑现",Unfulfilled:"7F-F-未兑现",Partial:"7F-F-部分兑现"},
+  E: {Willing:"7F-E-心甘情愿",Perfunctory:"7F-E-敷衍",Resentful:"7F-E-怨恨",Numb:"7F-E-麻木"},
+  A: {Self:"7F-A-自己",Partner:"7F-A-伴侣",Family:"7F-A-家庭",Outsider:"7F-A-外人",Public:"7F-A-公众"},
+  X: {OverExplain:"7F-X-过度解释",Silent:"7F-X-沉默",Genuine:"7F-X-真诚",Indifferent:"7F-X-冷漠"},
+  Y: {Changed:"7F-Y-改正",Resisted:"7F-Y-抗拒",Indifferent:"7F-Y-无视",NoResponse:"7F-Y-无响应"}
+};
+
+export class AuditWrapper {
+  constructor(uid="9622") { this.uid = uid; }
+
+  wrap(payload, taskType="default", persona="P04") {
+    const now = new Date();
+    const signature = {
+      P:"HasPromise", F:"Fulfilled", T:0.0, E:"Willing",
+      C:0, R:0, A:"Self", X:"Genuine", Y:"NoResponse", Z:1.0
+    };
+    const pattern = this._classify(signature);
+    const labels = this._makeLabels(signature, pattern);
+    const color = this._determineColor(pattern, signature.R);
+    const payloadJson = JSON.stringify(payload, Object.keys(payload).sort());
+    const payloadHash = crypto.createHash('sha256').update(payloadJson,'utf8').digest('hex').slice(0,16);
+    return {
+      audit_version:"v1.0", uid:`UID${this.uid}`, persona, task_type:taskType,
+      behavior_signature:signature, behavior_pattern:pattern, behavior_labels:labels,
+      color, timestamp:now.toISOString(), payload_hash:payloadHash
+    };
+  }
+
+  _classify(sig) {
+    const f = sig.F, x = sig.X, a = sig.A, y = sig.Y, z = sig.Z;
+    if (f==="Unfulfilled" && x==="OverExplain") return "MODE-DefensiveDefaulter";
+    if (f==="Fulfilled" && a==="Outsider") return "MODE-ExternalTrustSpender";
+    if (f==="Unfulfilled" && y==="Indifferent") return "MODE-InternalDestroyer";
+    if (z > 2.0) return "MODE-Fluctuating";
+    return "MODE-StableDisciplined";
+  }
+
+  _makeLabels(sig, pattern) {
+    const labels = [];
+    for (const factor of ["P","F","E","A","X","Y"]) {
+      const val = sig[factor];
+      if (LABEL_MAP[factor] && LABEL_MAP[factor][val]) labels.push(LABEL_MAP[factor][val]);
+    }
+    labels.push(pattern);
+    return labels;
+  }
+
+  _determineColor(pattern, repeat) {
+    if (pattern==="MODE-InternalDestroyer") return "🔴";
+    if (pattern==="MODE-Fluctuating" && repeat>3) return "🟡";
+    if (pattern==="MODE-DefensiveDefaulter" && repeat>2) return "🟡";
+    return "🟢";
+  }
+}
+
+const _wrapper = new AuditWrapper();
+export function auditWrap(payload, taskType="default", persona="P04") {
+  return _wrapper.wrap(payload, taskType, persona);
+}

adapters/javascript/src/dna_generator.js

@@ -0,0 +1,81 @@
+/**
+ * DNA Generator — v∞ format traceability code generation.
+ */
+import crypto from 'crypto';
+
+const TIAN_GAN = ["Jia","Yi","Bing","Ding","Wu","Ji","Geng","Xin","Ren","Gui"];
+const DI_ZHI = ["Zi","Chou","Yin","Mao","Chen","Si","Wu","Wei","Shen","You","Xu","Hai"];
+const SHI_CHEN = ["ZiShi","ChouShi","YinShi","MaoShi","ChenShi","SiShi","WuShi","WeiShi","ShenShi","YouShi","XuShi","HaiShi"];
+
+const HEXAGRAMS = [
+  {symbol:"䷀",enName:"Qian",cnName:"乾",domain:"governance"},
+  {symbol:"䷁",enName:"Kun",cnName:"坤",domain:"archive"},
+  {symbol:"䷂",enName:"Zhun",cnName:"屯",domain:"init"},
+  {symbol:"䷃",enName:"Meng",cnName:"蒙",domain:"learn"},
+  {symbol:"䷄",enName:"Xu",cnName:"需",domain:"async"},
+  {symbol:"䷅",enName:"Song",cnName:"讼",domain:"legal"},
+  {symbol:"䷜",enName:"Kan",cnName:"坎",domain:"engine"},
+  {symbol:"䷝",enName:"Li",cnName:"离",domain:"audit"},
+  {symbol:"䷲",enName:"Zhen",cnName:"震",domain:"security"},
+  {symbol:"䷳",enName:"Gen",cnName:"艮",domain:"privacy"},
+  {symbol:"䷸",enName:"Xun",cnName:"巽",domain:"deploy"},
+  {symbol:"䷹",enName:"Dui",cnName:"兑",domain:"trust"},
+  {symbol:"䷾",enName:"JiJi",cnName:"既济",domain:"complete"},
+  {symbol:"䷿",enName:"WeiJi",cnName:"未济",domain:"progress"}
+];
+
+const TASK_HEXAGRAM_MAP = {
+  default:"governance", code:"engine", deploy:"deploy", audit:"audit",
+  security:"security", archive:"archive", init:"init", learn:"learn",
+  legal:"legal", privacy:"privacy", trust:"trust", complete:"complete", progress:"progress"
+};
+
+export class DNAGenerator {
+  constructor(uid="9622", device="HM-9622-001", locale="Asia/Shanghai") {
+    this.uid = uid; this.device = device; this.locale = locale;
+  }
+
+  generate(taskType="default", action="WRAP", version=null) {
+    const now = new Date();
+    const stem = this._computeStemBranch(now);
+    const hexagram = this._selectHexagram(taskType);
+    version = version || "V1.0";
+    const body = `ADAPTER-${taskType.toUpperCase()}-${action.toUpperCase()}-${version}`;
+    const raw = `${stem.year}${stem.month}${stem.day}${stem.shichen}${hexagram.symbol}${hexagram.enName}${body}${this.device}${now.toISOString()}`;
+    const hash8 = crypto.createHash('sha256').update(raw, 'utf8').digest('hex').slice(0,8);
+    return `#LongHun⚡️${stem.year}·${stem.month}·${stem.day}·${stem.shichen}·${hexagram.symbol}${hexagram.enName}-${body}-${hash8}`;
+  }
+
+  _computeStemBranch(dt) {
+    const CYCLE_YEAR = 1984;
+    const CYCLE_MONTH = [2,4,6,8,10,0,2,4,6,8,10,0];
+    const year = dt.getUTCFullYear(), month = dt.getUTCMonth() + 1;
+    const dayOfYear = Math.floor((dt - new Date(Date.UTC(year,0,0))) / 86400000);
+    const hour = dt.getUTCHours();
+    const yearStemIdx = (year - CYCLE_YEAR) % 10;
+    const yearBranchIdx = (year - CYCLE_YEAR) % 12;
+    const msBase = CYCLE_MONTH[(year - CYCLE_YEAR) % 10] || 0;
+    const monthStemIdx = (msBase + month - 1) % 10;
+    const monthBranchIdx = (month + 1) % 12;
+    const dayStemIdx = (year - 1900 + Math.floor((year - 1900) / 4) + dayOfYear) % 10;
+    const dayBranchIdx = (year - 1900 + Math.floor((year - 1900) / 4) + dayOfYear) % 12;
+    const shichenIdx = Math.floor(hour / 2);
+    return {
+      year: TIAN_GAN[yearStemIdx] + DI_ZHI[yearBranchIdx],
+      month: TIAN_GAN[(monthStemIdx % 10 + 10) % 10] + DI_ZHI[monthBranchIdx],
+      day: TIAN_GAN[(dayStemIdx % 10 + 10) % 10] + DI_ZHI[(dayBranchIdx % 12 + 12) % 12],
+      shichen: SHI_CHEN[shichenIdx]
+    };
+  }
+
+  _selectHexagram(taskType) {
+    const domain = TASK_HEXAGRAM_MAP[taskType] || "governance";
+    const candidates = HEXAGRAMS.filter(h => h.domain === domain);
+    return candidates.length > 0 ? candidates[0] : HEXAGRAMS[0];
+  }
+}
+
+const _generator = new DNAGenerator();
+export function generateDna(taskType="default", action="WRAP", version=null) {
+  return _generator.generate(taskType, action, version);
+}

adapters/javascript/src/index.cjs

@@ -0,0 +1 @@
+module.exports = require('./index.js');

adapters/javascript/src/index.js

@@ -0,0 +1,57 @@
+/**
+ * LongHun Standard Adapter — JavaScript/TypeScript
+ */
+import { DNAGenerator, generateDna } from './dna_generator.js';
+import { AuditWrapper, auditWrap } from './audit_wrapper.js';
+import { Validator, quickValidate } from './validator.js';
+
+export class LongHunAdapter {
+  constructor(options = {}) {
+    const { uid = "9622", device = "HM-9622-001", locale = "Asia/Shanghai" } = options;
+    this.uid = uid; this.device = device; this.locale = locale;
+    this._dnaGen = new DNAGenerator(uid, device, locale);
+    this._audit = new AuditWrapper(uid);
+    this._validator = new Validator();
+  }
+
+  wrap(data, taskType = "default", persona = "P04", action = "WRAP", version = null) {
+    const dna = this._dnaGen.generate(taskType, action, version);
+    const audit = this._audit.wrap(data, taskType, persona);
+    return {
+      dna, audit, payload: data,
+      meta: {
+        adapter_version: "1.0.0", uid: this.uid, device: this.device,
+        task_type: taskType, persona,
+        generated_at: new Date().toISOString(), format: "longhun-v∞"
+      }
+    };
+  }
+
+  validate(wrapped) { return this._validator.validate(wrapped); }
+
+  getSchemas() {
+    return {
+      dnaSchema: {
+        type: "string",
+        pattern: "^#LongHun⚡️[A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+·[\\u4DC0-\\u4DFF][A-Za-z]+-.+-[a-f0-9]{8}$",
+        description: "v∞ DNA traceability code"
+      },
+      auditSchema: {
+        type: "object",
+        required: ["audit_version","uid","behavior_signature","behavior_pattern","behavior_labels","color"],
+        properties: {
+          audit_version: {type:"string"}, uid: {type:"string"},
+          behavior_signature: {type:"object", required:["P","F","T","E","C","R","A","X","Y","Z"]},
+          behavior_pattern: {type:"string"}, color: {type:"string", enum:["🟢","🟡","🔴"]},
+          payload_hash: {type:"string", pattern:"^[a-f0-9]{16}$"}
+        }
+      }
+    };
+  }
+}
+
+export function wrap(data, taskType="default", persona="P04", uid="9622", device="HM-9622-001") {
+  return new LongHunAdapter({uid, device}).wrap(data, taskType, persona);
+}
+
+export { DNAGenerator, AuditWrapper, Validator, generateDna, auditWrap, quickValidate };