ai-worklens-agent 0.1.0

package/src/hook-adapter.mjs

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+import { loadClientConfig } from "./config.mjs";
+import { buildEvent } from "./event-builder.mjs";
+import { ClientAgent } from "./uploader.mjs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  return JSON.parse(raw);
+}
+
+function parseArgs(argv) {
+  const result = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) result[key] = true;
+    else {
+      result[key] = next;
+      index += 1;
+    }
+  }
+  return result;
+}
+
+function hookName(payload, args) {
+  return String(
+    args.event ||
+    args.hook ||
+    payload.event ||
+    payload.eventName ||
+    payload.event_name ||
+    payload.hook ||
+    payload.hook_event ||
+    payload.hook_event_name ||
+    payload.hookEventName ||
+    payload.type ||
+    ""
+  ).trim().toLowerCase();
+}
+
+function eventTypeFromHook(name, payload) {
+  const compact = name.replace(/[^a-z0-9]/g, "");
+  const explicit = payload.eventType || payload.event_type;
+  if (explicit) return explicit;
+  if (["modechange", "modechanged", "codexmodechange", "planmodestart", "planmodeend"].includes(compact)) return "mode_change";
+  if (["sessionstatus", "sessionupdated"].includes(compact) && modeFromPayload(payload)) return "mode_change";
+  if (["sessionstart", "setup", "sessioncreated", "serverconnected"].includes(compact)) return "session_start";
+  if (["sessionend", "stop", "subagentstop", "teammateidle", "sessionidle", "sessiondeleted"].includes(compact)) return "session_end";
+  if (["userpromptsubmit", "userprompt", "promptsubmit"].includes(compact)) return "user_prompt";
+  if (["tuipromptappend"].includes(compact)) return "user_prompt";
+  if (["user_prompt", "prompt", "user_message", "user_input"].includes(name)) return "user_prompt";
+  if (["messageupdated", "messagepartupdated", "assistantresponse", "assistantturn", "assistantmessage"].includes(compact)) return "assistant_response";
+  if (["assistant_response", "assistant_turn", "assistant_message", "ai_response"].includes(name)) return "assistant_response";
+  if (["skill_use", "skill"].includes(name)) return "skill_use";
+  if (["plugin_use", "plugin"].includes(name)) return "plugin_use";
+  if (["mcp_tool_call", "mcp"].includes(name)) return "mcp_tool_call";
+  if (["permissionrequest", "permissionasked", "permissionreplied", "permissiondenied"].includes(compact)) return "permission";
+  if (["posttoolusefailure", "stopfailure", "permissiondenied", "sessionerror"].includes(compact)) return "error";
+  if (["filechanged", "fileedited", "sessiondiff", "worktreecreate", "worktreeremove"].includes(compact)) return "implementation";
+  if (["taskcreated", "todoupdated", "precompact"].includes(compact)) return "planning";
+  if (["taskcompleted", "postcompact"].includes(compact)) return "implementation";
+  if (["lspclientdiagnostics"].includes(compact)) return "verification";
+  if (["pretooluse", "toolcall", "tooluse", "toolusebefore", "toolexecutebefore"].includes(compact)) {
+    const toolName = toolNameFromPayload(payload);
+    const command = commandFromPayload(payload);
+    return /bash|shell|terminal|command/i.test(toolName) ? commandEventType(command) : "tool_call";
+  }
+  if (["posttooluse", "posttoolbatch", "tooluseafter", "toolexecuteafter"].includes(compact)) {
+    const toolName = toolNameFromPayload(payload);
+    const command = commandFromPayload(payload);
+    return /bash|shell|terminal|command/i.test(toolName) ? commandEventType(command) : "tool_result";
+  }
+  if (["commandexecuted", "tuicommandexecute"].includes(compact)) return commandEventType(commandFromPayload(payload));
+  if (["command", "command_exit", "post_command"].includes(name)) {
+    return commandEventType(commandFromPayload(payload));
+  }
+  if (["tool_call", "tool"].includes(name)) return "tool_call";
+  if (["verification", "test", "build"].includes(name)) return "verification";
+  if (["error", "failure"].includes(name)) return "error";
+  if (["retry", "rerun"].includes(name)) return "retry";
+  if (["rework", "fix"].includes(name)) return "rework";
+  if (["session_start"].includes(name)) return "session_start";
+  if (["session_end"].includes(name)) return "session_end";
+  return "tool_call";
+}
+
+function commandEventType(command) {
+  return /test|lint|typecheck|build|playwright|smoke|check/i.test(command) ? "verification" : "command";
+}
+
+function toolNameFromPayload(payload) {
+  return payload.toolName ||
+    payload.tool_name ||
+    payload.tool ||
+    payload.input?.tool ||
+    payload.output?.tool ||
+    payload.request?.tool ||
+    "";
+}
+
+function firstText(...values) {
+  for (const value of values) {
+    if (value === undefined || value === null || value === "") continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+  }
+  return "";
+}
+
+function modeFromPayload(payload) {
+  return firstText(
+    payload.mode,
+    payload.codexMode,
+    payload.codex_mode,
+    payload.status?.mode,
+    payload.session?.mode,
+    payload.input?.mode,
+    payload.output?.mode,
+    payload.output?.status,
+    payload.status
+  );
+}
+
+function previousModeFromPayload(payload) {
+  return firstText(
+    payload.previousMode,
+    payload.previous_mode,
+    payload.fromMode,
+    payload.from_mode,
+    payload.oldMode,
+    payload.old_mode,
+    payload.input?.previousMode,
+    payload.input?.fromMode,
+    payload.output?.previousMode
+  );
+}
+
+function nextModeFromPayload(payload) {
+  return firstText(
+    payload.nextMode,
+    payload.next_mode,
+    payload.toMode,
+    payload.to_mode,
+    payload.newMode,
+    payload.new_mode,
+    payload.input?.nextMode,
+    payload.input?.toMode,
+    payload.output?.nextMode,
+    modeFromPayload(payload)
+  );
+}
+
+function commandFromPayload(payload) {
+  return payload.commands ||
+    payload.command ||
+    payload.cmd ||
+    payload.args?.command ||
+    payload.input?.command ||
+    payload.output?.command ||
+    payload.tool_input?.command ||
+    payload.toolInput?.command ||
+    payload.tool_args?.command ||
+    "";
+}
+
+function statusFromPayload(payload) {
+  if (payload.success === true || payload.output?.success === true) return "success";
+  if (payload.success === false || payload.output?.success === false) return "failed";
+  return firstText(
+    payload.status,
+    payload.output?.status,
+    payload.result?.status,
+    payload.error ? "failed" : ""
+  );
+}
+
+function permissionDecisionFromPayload(payload) {
+  return firstText(
+    payload.decision,
+    payload.permission?.decision,
+    payload.output?.decision,
+    payload.output?.permission?.decision,
+    payload.input?.decision,
+    /denied|deny/i.test(String(payload.status || payload.error || "")) ? "denied" : ""
+  );
+}
+
+function fileRefsFromPayload(payload) {
+  return payload.files ||
+    payload.changedFiles ||
+    payload.changed_files ||
+    payload.file ||
+    payload.filePath ||
+    payload.file_path ||
+    payload.path ||
+    payload.input?.file ||
+    payload.input?.path ||
+    payload.input?.filePath ||
+    payload.input?.file_path ||
+    payload.output?.file ||
+    payload.output?.path ||
+    payload.tool_input?.file_path ||
+    payload.tool_input?.filePath ||
+    payload.toolInput?.file_path ||
+    payload.toolInput?.filePath;
+}
+
+function pickSummary(payload, name, eventType) {
+  if (eventType === "mode_change") {
+    const previousMode = previousModeFromPayload(payload);
+    const nextMode = nextModeFromPayload(payload);
+    return {
+      title: nextMode ? `模式切换：${nextMode}` : "模式切换",
+      content: previousMode && nextMode ? `${previousMode} -> ${nextMode}` : (nextMode || modeFromPayload(payload) || `hook:${name}`)
+    };
+  }
+  if (eventType === "permission") {
+    const decision = permissionDecisionFromPayload(payload);
+    const toolName = toolNameFromPayload(payload);
+    return {
+      title: decision ? `权限：${decision}` : "权限决策",
+      content: [toolName, decision, payload.reason || payload.error || payload.message].filter(Boolean).join(" / ") || `hook:${name}`
+    };
+  }
+  const title = payload.title ||
+    payload.summary?.title ||
+    payload.skillName ||
+    payload.skill_name ||
+    payload.pluginName ||
+    payload.plugin_name ||
+    payload.mcpServer ||
+    payload.mcp_server ||
+    payload.toolName ||
+    payload.tool_name ||
+    payload.tool ||
+    payload.input?.tool ||
+    payload.output?.tool ||
+    eventType;
+  const content = payload.content ||
+    payload.summary?.content ||
+    payload.summary ||
+    payload.message ||
+    payload.prompt ||
+    payload.promptText ||
+    payload.responseSummary ||
+    payload.command ||
+    payload.cmd ||
+    payload.args?.command ||
+    payload.input?.command ||
+    payload.output?.command ||
+    payload.tool_input?.command ||
+    payload.toolInput?.command ||
+    payload.reason ||
+    payload.error ||
+    payload.status ||
+    `hook:${name}`;
+  return { title, content };
+}
+
+export function normalizeHookPayload(payload, args, config) {
+  const name = hookName(payload, args);
+  const eventType = eventTypeFromHook(name, payload);
+  const summary = pickSummary(payload, name, eventType);
+  const metadata = payload.metadata && typeof payload.metadata === "object" ? payload.metadata : {};
+  return buildEvent({
+    ...payload,
+    eventType,
+    source: payload.source || `${config.tool}_hook`,
+    title: summary.title,
+    content: summary.content,
+    hookName: name,
+    localSessionId: payload.sessionId || payload.session_id || payload.localSessionId,
+    turnIndex: payload.turnIndex || payload.turn_index,
+    skillName: payload.skillName || payload.skill_name || payload.skill,
+    pluginName: payload.pluginName || payload.plugin_name || payload.plugin,
+    mcpServer: payload.mcpServer || payload.mcp_server || payload.server,
+    files: fileRefsFromPayload(payload),
+    commands: commandFromPayload(payload),
+    durationSeconds: payload.durationSeconds || payload.duration_seconds || payload.duration_ms && Number(payload.duration_ms) / 1000,
+    metadata: {
+      ...metadata,
+      hookAdapter: "ai-worklens",
+      sourceTool: config.tool,
+      rawHookEvent: name,
+      hookEventName: payload.hook_event_name || payload.hookEventName || payload.event || payload.type || name,
+      toolName: toolNameFromPayload(payload),
+      codexMode: nextModeFromPayload(payload),
+      interactionType: eventType,
+      cwd: payload.cwd || payload.directory || payload.project?.directory,
+      transcriptPath: payload.transcript_path || payload.transcriptPath,
+      permissionDecision: permissionDecisionFromPayload(payload),
+      exitCode: payload.exitCode ?? payload.exit_code,
+      success: payload.success,
+      status: statusFromPayload(payload)
+    },
+    process: {
+      interactionType: eventType,
+      codexMode: nextModeFromPayload(payload),
+      previousMode: previousModeFromPayload(payload),
+      nextMode: nextModeFromPayload(payload),
+      phase: payload.phase || payload.input?.phase || payload.output?.phase,
+      toolName: toolNameFromPayload(payload),
+      toolStatus: statusFromPayload(payload),
+      exitCode: payload.exitCode ?? payload.exit_code ?? payload.output?.exitCode ?? payload.output?.exit_code,
+      permissionDecision: permissionDecisionFromPayload(payload),
+      retryAttempt: payload.retryAttempt || payload.retry_attempt || payload.attempt || payload.input?.attempt,
+      failureKind: payload.failureKind || payload.failure_kind || payload.errorCode || payload.error_code || payload.error?.code
+    }
+  }, config);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const payload = await readStdin();
+  const config = loadClientConfig({
+    configFile: args.config,
+    queueFile: args.queue,
+    serverUrl: args["server-url"],
+    collectorToken: args["collector-token"],
+    employeeId: args["employee-id"],
+    employeeName: args["employee-name"],
+    department: args.department,
+    role: args.role,
+    clientId: args["client-id"],
+    tool: args.tool,
+    modelProvider: args["model-provider"] || payload.modelProvider || payload.model_provider,
+    modelName: args["model-name"] || payload.modelName || payload.model_name || payload.model,
+    modelVersion: args["model-version"] || payload.modelVersion || payload.model_version,
+    modelFamily: args["model-family"] || payload.modelFamily || payload.model_family,
+    repoName: args["repo-name"],
+    workspaceRoot: args.workspace,
+    branch: args.branch
+  });
+  const event = normalizeHookPayload(payload, args, config);
+  const agent = new ClientAgent(config);
+  const result = await agent.record(event);
+  process.stdout.write(`${JSON.stringify({ ok: true, hook: event.metadata.rawHookEvent, eventType: event.eventType, eventId: event.eventId, result })}\n`);
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] || "")) {
+  main().catch((error) => {
+    process.stderr.write(`${JSON.stringify({ ok: false, error: error.message })}\n`);
+    process.exitCode = 1;
+  });
+}

package/src/hook-smoke.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadClientConfig } from "./config.mjs";
+import { normalizeHookPayload } from "./hook-adapter.mjs";
+import { normalizeToolId } from "../../collector-protocol/src/tool-profiles.mjs";
+
+const SAMPLE_PAYLOADS = {
+  codex: {
+    event: "plugin_use",
+    pluginName: "Figma",
+    message: "使用 Figma 插件同步设计稿信息",
+    sessionId: "smoke-codex"
+  },
+  "claude-code": {
+    hook_event_name: "PostToolUse",
+    tool_name: "Bash",
+    tool_input: { command: "npm test" },
+    session_id: "smoke-claude"
+  },
+  opencode: {
+    event: "tool.execute.after",
+    input: { tool: "bash", command: "npm run build" },
+    sessionId: "smoke-opencode"
+  }
+};
+
+function parseArgs(argv) {
+  const result = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) result[key] = true;
+    else {
+      result[key] = next;
+      index += 1;
+    }
+  }
+  return result;
+}
+
+function selectedTools(tool) {
+  if (!tool || tool === "all") return Object.keys(SAMPLE_PAYLOADS);
+  return [normalizeToolId(tool)];
+}
+
+export function runHookSmoke(config, options = {}) {
+  const tools = selectedTools(options.tool);
+  const items = tools.map((tool) => {
+    const payload = SAMPLE_PAYLOADS[tool];
+    if (!payload) {
+      return { tool, ok: false, error: "unsupported tool" };
+    }
+    try {
+      const event = normalizeHookPayload(payload, { event: payload.event || payload.hook_event_name }, {
+        ...config,
+        tool
+      });
+      return {
+        tool,
+        ok: true,
+        source: event.source,
+        eventType: event.eventType,
+        summary: event.summary.title,
+        commands: event.refs.commands,
+        files: event.refs.files
+      };
+    } catch (error) {
+      return { tool, ok: false, error: error.message };
+    }
+  });
+  return {
+    ok: items.every((item) => item.ok),
+    checkedAt: new Date().toISOString(),
+    items
+  };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const config = loadClientConfig({
+    configFile: args.config,
+    queueFile: args.queue,
+    employeeId: args["employee-id"] || "SMOKE",
+    employeeName: args["employee-name"] || "Hook Smoke",
+    department: args.department || "验证",
+    role: args.role || "验证",
+    clientId: args["client-id"] || "hook-smoke",
+    tool: args.tool === "all" ? "codex" : args.tool,
+    modelProvider: args["model-provider"],
+    modelName: args["model-name"],
+    modelVersion: args["model-version"],
+    modelFamily: args["model-family"]
+  });
+  process.stdout.write(`${JSON.stringify(runHookSmoke(config, { tool: args.tool || "all" }), null, 2)}\n`);
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] || "")) {
+  main().catch((error) => {
+    process.stderr.write(`${JSON.stringify({ ok: false, error: error.message })}\n`);
+    process.exitCode = 1;
+  });
+}