@maidang1/hataraku 0.0.3

package/src/core/internal/observability/logging/types.ts

@@ -0,0 +1,53 @@
+export type SessionEvent =
+  | { type: "session_start"; ts: string; sessionId: string; projectRoot: string }
+  | { type: "user_message"; ts: string; content: string }
+  | { type: "assistant_start"; ts: string; content: string }
+  | { type: "assistant_delta"; ts: string; delta: string }
+  | { type: "assistant_thinking_start"; ts: string; content: string; redacted?: boolean }
+  | { type: "assistant_thinking_delta"; ts: string; delta: string }
+  | { type: "assistant_thinking_end"; ts: string }
+  | { type: "assistant_end"; ts: string }
+  | { type: "tool_use"; ts: string; toolName: string; input: unknown; preview?: string }
+  | {
+      type: "tool_result";
+      ts: string;
+      toolName: string;
+      ok: boolean;
+      content: string;
+      filesChanged?: string[];
+    }
+  | {
+      type: "confirm_request";
+      ts: string;
+      confirmId: string;
+      toolName: string;
+      reason: string;
+      preview?: string;
+    }
+  | { type: "confirm_response"; ts: string; confirmId: string; allowed: boolean }
+  | { type: "error"; ts: string; message: string; stack?: string };
+
+export type EnvSnapshot = {
+  ts: string;
+  os: {
+    platform: string;
+    release: string;
+    arch: string;
+    cpus: number;
+  };
+  runtime: {
+    bunVersion?: string;
+    nodeVersion: string;
+  };
+  shell?: string;
+  cwd: string;
+  git?: {
+    branch?: string;
+    status?: string;
+  };
+};
+
+export type ExportOptions = {
+  sessionDir: string;
+  outPath: string;
+};

package/src/core/internal/policy/index.ts

@@ -0,0 +1 @@
+export * as safetyPolicy from "./safety";

package/src/core/internal/policy/safety/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./policy";

package/src/core/internal/policy/safety/policy.ts

@@ -0,0 +1,96 @@
+import path from "path";
+import type { SafetyAction, SafetyDecision, SafetyPolicyConfig } from "./types";
+
+function isWithinRoots(targetPath: string, roots: string[]): boolean {
+  const resolvedTarget = path.resolve(targetPath);
+  return roots.some((root) => {
+    const resolvedRoot = path.resolve(root);
+    const rel = path.relative(resolvedRoot, resolvedTarget);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+  });
+}
+
+function getBashPrefix(command: string): string {
+  return command.trim().split(/\s+/).slice(0, 2).join(" ");
+}
+
+export class SafetyPolicy {
+  private config: SafetyPolicyConfig;
+
+  constructor(config: SafetyPolicyConfig) {
+    this.config = config;
+  }
+
+  decide(action: SafetyAction): SafetyDecision {
+    const projectRoot = this.config.projectRoot;
+    const allowedWriteRoots = this.config.allowedWriteRoots?.length
+      ? this.config.allowedWriteRoots
+      : [projectRoot];
+
+    if (action.type === "bash") {
+      const prefix = getBashPrefix(action.command);
+      const autoPrefixes = this.config.autoAllowedBashPrefixes ?? [
+        "rg",
+        "cat",
+        "ls",
+        "pwd",
+        "git status",
+        "git diff",
+        "git log",
+      ];
+
+      if (autoPrefixes.some((p) => prefix === p || action.command.trim().startsWith(p + " "))) {
+        return { allowed: true, requiresConfirm: false, reason: `Auto-allowed command: ${prefix}` };
+      }
+
+      return { allowed: true, requiresConfirm: true, reason: "Command execution requires confirmation" };
+    }
+
+    if (action.type === "tool") {
+      const toolName = action.toolName;
+      if (
+        toolName === "fileRead" ||
+        toolName === "listFiles" ||
+        toolName === "grep" ||
+        toolName === "glob" ||
+        toolName === "architect" ||
+        toolName === "todo_read" ||
+        toolName === "skills"
+      ) {
+        return { allowed: true, requiresConfirm: false, reason: "Read-only tool" };
+      }
+
+      if (toolName === "fileEdit" || toolName === "todo_write") {
+        const input = action.input as any;
+        const filePath =
+          typeof input?.path === "string"
+            ? input.path
+            : typeof input?.filePath === "string"
+              ? input.filePath
+              : "";
+        if (filePath && !isWithinRoots(path.resolve(projectRoot, filePath), allowedWriteRoots)) {
+          return {
+            allowed: false,
+            requiresConfirm: false,
+            reason: `Write path is outside allowed roots: ${filePath}`,
+          };
+        }
+        return { allowed: true, requiresConfirm: true, reason: "File write requires confirmation" };
+      }
+
+      if (toolName === "fetch") {
+        return { allowed: true, requiresConfirm: true, reason: "Network access requires confirmation" };
+      }
+
+      if (toolName === "bash") {
+        const input = action.input as any;
+        const command = typeof input?.command === "string" ? input.command : "";
+        return this.decide({ type: "bash", command, preview: action.preview });
+      }
+
+      return { allowed: true, requiresConfirm: true, reason: `Tool requires confirmation: ${toolName}` };
+    }
+
+    return { allowed: true, requiresConfirm: true, reason: "Unknown action requires confirmation" };
+  }
+}

package/src/core/internal/policy/safety/types.ts

@@ -0,0 +1,24 @@
+export type SafetyAction =
+  | {
+      type: "tool";
+      toolName: string;
+      input: unknown;
+      preview?: string;
+    }
+  | {
+      type: "bash";
+      command: string;
+      preview?: string;
+    };
+
+export type SafetyDecision = {
+  allowed: boolean;
+  requiresConfirm: boolean;
+  reason: string;
+};
+
+export type SafetyPolicyConfig = {
+  projectRoot: string;
+  allowedWriteRoots?: string[];
+  autoAllowedBashPrefixes?: string[];
+};

package/src/core/internal/providers/anthropic/client.ts

@@ -0,0 +1,20 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { getEffectiveConfig } from "../../config";
+
+export function createAnthropicClient(): Anthropic {
+  const config = getEffectiveConfig();
+  return new Anthropic({
+    baseURL: config.baseURL || process.env.ANTHROPIC_BASE_URL,
+    authToken: config.authToken || process.env.ANTHROPIC_AUTH_TOKEN,
+    apiKey: config.apiKey,
+  });
+}
+
+let cachedClient: Anthropic | null = null;
+
+export function getAnthropicClient(): Anthropic {
+  if (!cachedClient) {
+    cachedClient = createAnthropicClient();
+  }
+  return cachedClient;
+}

package/src/core/internal/providers/anthropic/index.ts

@@ -0,0 +1 @@
+export * from "./client";

package/src/core/internal/providers/index.ts

@@ -0,0 +1 @@
+export * from "./anthropic";