pasika 0.1.0

package/AGENTS.md

@@ -0,0 +1,15 @@
+# pasika
+pasika scope and usage.
+Full documentation: docs/common/overview.md
+
+---
+
+# Merge Behavior
+How pasika merges into existing Claude settings.
+Full documentation: docs/common/merge-behavior.md
+
+---
+
+# Claude Hooks
+Shared Claude hooks shipped by pasika.
+Full documentation: docs/claude/hooks.md

package/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/README.md

@@ -0,0 +1,112 @@
+# pasika
+
+Reusable base assets for Claude Code setups.
+
+`pasika` stores portable Claude base config assets that individual repos can copy from or adapt.
+
+## Scope
+
+This repo intentionally starts narrow:
+
+- Claude only for v1
+- reusable base config only
+- shared docs at the repo root
+- no project-specific rules, workflows, or business logic
+
+## Layout
+
+```text
+claude/
+  scripts/
+    render-settings.ts
+  .claude/
+    settings.base.json
+    hooks/
+      status-line/
+        index.js
+      notification.sh
+      protect-files.sh
+docs/
+  common/
+    overview.md
+    merge-behavior.md
+  claude/
+    hooks.md
+scripts/
+  pasika.ts
+dist/
+  ...
+vulyk.json
+AGENTS.md
+CLAUDE.md
+```
+
+## What belongs here
+
+- portable hook scripts
+- base settings templates
+- shared docs and generated `CLAUDE.md`
+- shared naming and layout conventions
+
+## What stays in project repos
+
+- final `.claude` folders
+- project-specific skills, rules, agents, and prompts
+- repository-specific plugin choices
+- scripts that depend on a specific app, CI setup, or codebase
+
+## CLI
+
+The main entry point is:
+
+```bash
+npx pasika claude
+```
+
+Optional flags:
+
+- `--target-dir <path>` writes into another repo
+- `--force` replaces an existing generated file instead of merging
+
+## Development
+
+The CLI source lives in TypeScript.
+
+```bash
+npm run lint
+npm run typecheck
+npm run build
+```
+
+`npm run build` uses `vulyk docs` to emit root `AGENTS.md` and `CLAUDE.md`.
+
+## Recommended Integration
+
+Hooks and helper executables should come from `node_modules`.
+
+That gives us:
+
+- versioned reusable scripts
+- easy upgrades through the package manager
+- no manual copying of hook files into every repo
+
+`settings.json` is different. It still needs to exist in each project repo, because Claude Code does not give us a clean inheritance model for it.
+
+So the recommended pattern is:
+
+1. install `pasika` as a dev dependency
+2. run `npx pasika claude`
+3. generate or merge into `.claude/settings.json` in the project
+4. point hook commands at `./node_modules/pasika/claude/...`
+5. keep project-specific plugin, skill, and rule decisions in the project repo
+
+## Merge Behavior
+
+By default, `pasika` merges its Claude base into an existing `.claude/settings.json`.
+
+That means:
+
+- it updates the portable base pieces shipped by `pasika`
+- it preserves unrelated project-specific settings such as extra hooks, plugin config, and custom permissions
+
+Use `--force` only when you want to replace the existing file with the `pasika` base output.

package/claude/.claude/hooks/notification.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# notification.sh - Cross-platform notification
+
+OS="$(uname -s)"
+
+case "$OS" in
+  Darwin*)
+    if command -v terminal-notifier &> /dev/null; then
+      PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+      TEMP_SCRIPT=$(mktemp)
+
+      cat > "$TEMP_SCRIPT" <<SCRIPTEND
+#!/bin/bash
+/usr/local/bin/code -r "$PROJECT_DIR"
+sleep 0.5
+osascript -e 'tell application "Visual Studio Code" to activate'
+SCRIPTEND
+
+      chmod +x "$TEMP_SCRIPT"
+
+      terminal-notifier \
+        -message "Claude Code needs your attention - Click to focus terminal" \
+        -title "Claude Code" \
+        -sound Ping \
+        -execute "$TEMP_SCRIPT"
+
+      (sleep 60; rm -f "$TEMP_SCRIPT") &
+    else
+      osascript -e 'display notification "Claude Code needs your attention" with title "Claude Code"'
+    fi
+    ;;
+  Linux*)
+    notify-send 'Claude Code' 'Claude Code needs your attention'
+    ;;
+  MINGW*|MSYS*|CYGWIN*)
+    powershell.exe -Command "[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('Claude Code needs your attention', 'Claude Code')"
+    ;;
+esac

package/claude/.claude/hooks/protect-files.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# protect-files.sh - Block edits to sensitive files
+
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+
+PROTECTED_PATTERNS=(
+  "/\.env$|^\.env$"
+  "package-lock\.json$"
+  "/\.git/|^\.git/"
+)
+
+for pattern in "${PROTECTED_PATTERNS[@]}"; do
+  if echo "$FILE_PATH" | grep -qE "$pattern"; then
+    echo "Blocked: Cannot edit protected file '$FILE_PATH'" >&2
+    echo "Reason: This is a sensitive/generated file that should not be manually edited" >&2
+    exit 2
+  fi
+done
+
+exit 0

package/claude/.claude/hooks/status-line/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+import { execSync } from "node:child_process";
+import path from "node:path";
+
+let input = "";
+
+process.stdin.on("data", (chunk) => {
+  input += chunk;
+});
+
+process.stdin.on("end", () => {
+  try {
+    const data = JSON.parse(input || "{}");
+    const model = data.model?.display_name || data.model?.name || "Claude";
+    const dir = path.basename(data.workspace?.current_dir || process.cwd());
+    const cost = Number(data.cost?.total_cost_usd || 0);
+    const pct = Math.floor(Number(data.context_window?.used_percentage || 0));
+    const durationMs = Number(data.cost?.total_duration_ms || 0);
+
+    const CYAN = "\x1b[36m";
+    const GREEN = "\x1b[32m";
+    const YELLOW = "\x1b[33m";
+    const RED = "\x1b[31m";
+    const RESET = "\x1b[0m";
+
+    let barColor = GREEN;
+    if (pct >= 90) {
+      barColor = RED;
+    } else if (pct >= 70) {
+      barColor = YELLOW;
+    }
+
+    const filled = Math.max(0, Math.min(10, Math.floor(pct / 10)));
+    const bar = "█".repeat(filled) + "░".repeat(10 - filled);
+    const mins = Math.floor(durationMs / 60000);
+    const secs = Math.floor((durationMs % 60000) / 1000);
+
+    let branch = "";
+    try {
+      branch = execSync("git branch --show-current", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"],
+      }).trim();
+      branch = branch ? ` | 🌿 ${branch}` : "";
+    } catch {
+      branch = "";
+    }
+
+    process.stdout.write(`${CYAN}[${model}]${RESET} 📁 ${dir}${branch}\n`);
+    process.stdout.write(
+      `${barColor}${bar}${RESET} ${pct}% | ${YELLOW}$${cost.toFixed(2)}${RESET} | ⏱️ ${mins}m ${secs}s\n`,
+    );
+  } catch {
+    process.stdout.write("Claude\n");
+  }
+});

package/claude/.claude/settings.base.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "attribution": {
+    "commit": "",
+    "pr": ""
+  },
+  "permissions": {
+    "ask": ["Bash(git commit:*)", "Bash(git push:*)"]
+  },
+  "hooks": {
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/notification.sh"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/protect-files.sh"
+          }
+        ]
+      }
+    ]
+  },
+  "statusLine": {
+    "type": "command",
+    "command": "node $CLAUDE_PROJECT_DIR/.claude/hooks/status-line/index.js"
+  }
+}

package/claude/scripts/render-settings.ts

@@ -0,0 +1,207 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { constants } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface ClaudeSettings {
+  $schema?: string;
+  attribution?: Record<string, unknown>;
+  permissions?: {
+    ask?: string[];
+    deny?: string[];
+  };
+  hooks: {
+    Notification?: HookMatcherEntry[];
+    PreToolUse?: HookMatcherEntry[];
+    [key: string]: unknown;
+  };
+  statusLine: {
+    type?: string;
+    command: string;
+  };
+  [key: string]: unknown;
+}
+
+interface CommandHook {
+  type?: string;
+  command: string;
+  [key: string]: unknown;
+}
+
+interface HookMatcherEntry {
+  matcher?: string;
+  hooks: CommandHook[];
+  [key: string]: unknown;
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null;
+
+const fileExists = async (filePath: string): Promise<boolean> => {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const isClaudeSettings = (value: unknown): value is ClaudeSettings => {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  const hooks = value.hooks;
+  const statusLine = value.statusLine;
+
+  if (!isRecord(hooks) || !isRecord(statusLine) || typeof statusLine.command !== "string") {
+    return false;
+  }
+
+  const notification = hooks.Notification;
+  if (notification !== undefined && !Array.isArray(notification)) {
+    return false;
+  }
+
+  const preToolUse = hooks.PreToolUse;
+  return preToolUse === undefined || Array.isArray(preToolUse);
+};
+
+const readClaudeSettings = async (templatePath: string): Promise<ClaudeSettings> => {
+  const templateRaw = await readFile(templatePath, "utf8");
+  const parsed: unknown = JSON.parse(templateRaw);
+
+  if (!isClaudeSettings(parsed)) {
+    throw new Error("Claude settings template has an invalid shape.");
+  }
+
+  return parsed;
+};
+
+const mergeStringArrays = (left: string[] = [], right: string[] = []): string[] =>
+  Array.from(new Set([...left, ...right]));
+
+const upsertHookMatcherEntry = (
+  entries: HookMatcherEntry[] | undefined,
+  matcher: string,
+  command: string,
+): HookMatcherEntry[] => {
+  const nextEntries = [...(entries ?? [])];
+  const existingIndex = nextEntries.findIndex((entry) => (entry.matcher ?? "") === matcher);
+  const hook: CommandHook = { type: "command", command };
+
+  if (existingIndex === -1) {
+    nextEntries.push({ matcher, hooks: [hook] });
+    return nextEntries;
+  }
+
+  const existingEntry = nextEntries[existingIndex];
+  nextEntries[existingIndex] = { ...existingEntry, hooks: [hook] };
+  return nextEntries;
+};
+
+const mergeClaudeSettings = (
+  existingSettings: ClaudeSettings,
+  baseSettings: ClaudeSettings,
+  packagePath: string,
+): ClaudeSettings => {
+  const notificationCommand = `${packagePath}/.claude/hooks/notification.sh`;
+  const protectFilesCommand = `${packagePath}/.claude/hooks/protect-files.sh`;
+  const statusLineCommand = `node ${packagePath}/.claude/hooks/status-line/index.js`;
+
+  return {
+    ...existingSettings,
+    $schema: baseSettings.$schema ?? existingSettings.$schema,
+    attribution: { ...(baseSettings.attribution ?? {}), ...(existingSettings.attribution ?? {}) },
+    permissions: {
+      ...(existingSettings.permissions ?? {}),
+      ...(baseSettings.permissions ?? {}),
+      ask: mergeStringArrays(baseSettings.permissions?.ask, existingSettings.permissions?.ask),
+      deny: mergeStringArrays(baseSettings.permissions?.deny, existingSettings.permissions?.deny),
+    },
+    hooks: {
+      ...existingSettings.hooks,
+      Notification: upsertHookMatcherEntry(existingSettings.hooks.Notification, "", notificationCommand),
+      PreToolUse: upsertHookMatcherEntry(existingSettings.hooks.PreToolUse, "Edit|Write", protectFilesCommand),
+    },
+    statusLine: {
+      ...existingSettings.statusLine,
+      ...baseSettings.statusLine,
+      type: "command",
+      command: statusLineCommand,
+    },
+  };
+};
+
+export const renderClaude = async (targetDir: string, force: boolean, packageRoot: string): Promise<string[]> => {
+  const templatePath = path.join(packageRoot, "claude/.claude/settings.base.json");
+  const baseSettings = await readClaudeSettings(templatePath);
+  const packagePath = "./node_modules/pasika/claude";
+  const notificationEntries = upsertHookMatcherEntry(
+    baseSettings.hooks.Notification,
+    "",
+    `${packagePath}/.claude/hooks/notification.sh`,
+  );
+  const preToolUseEntries = upsertHookMatcherEntry(
+    baseSettings.hooks.PreToolUse,
+    "Edit|Write",
+    `${packagePath}/.claude/hooks/protect-files.sh`,
+  );
+  const settings: ClaudeSettings = {
+    ...baseSettings,
+    hooks: {
+      ...baseSettings.hooks,
+      Notification: notificationEntries,
+      PreToolUse: preToolUseEntries,
+    },
+    statusLine: {
+      ...baseSettings.statusLine,
+      type: "command",
+      command: `node ${packagePath}/.claude/hooks/status-line/index.js`,
+    },
+  };
+
+  const outputDir = path.join(targetDir, ".claude");
+  const outputPath = path.join(outputDir, "settings.json");
+
+  await mkdir(outputDir, { recursive: true });
+
+  const finalSettings =
+    !force && (await fileExists(outputPath))
+      ? mergeClaudeSettings(await readClaudeSettings(outputPath), settings, packagePath)
+      : settings;
+
+  await writeFile(outputPath, `${JSON.stringify(finalSettings, null, 2)}\n`, "utf8");
+
+  return [outputPath];
+};
+
+const isDirectRun = process.argv[1] ? path.resolve(process.argv[1]) === __filename : false;
+
+if (isDirectRun) {
+  const args = process.argv.slice(2);
+  const getArgValue = (flag: string): string | undefined => {
+    const index = args.indexOf(flag);
+    if (index === -1) {
+      return undefined;
+    }
+
+    return args[index + 1];
+  };
+
+  const targetDir = path.resolve(process.cwd(), getArgValue("--target-dir") ?? ".");
+  const force = args.includes("--force");
+  const packageRoot = path.resolve(__dirname, "../..");
+
+  try {
+    const outputs = await renderClaude(targetDir, force, packageRoot);
+    for (const output of outputs) {
+      process.stdout.write(`Wrote ${output}\n`);
+    }
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+}

package/dist/claude/scripts/render-settings.js

@@ -0,0 +1,132 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { constants } from "node:fs";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const isRecord = (value) => typeof value === "object" && value !== null;
+const fileExists = async (filePath) => {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const isClaudeSettings = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const hooks = value.hooks;
+    const statusLine = value.statusLine;
+    if (!isRecord(hooks) || !isRecord(statusLine) || typeof statusLine.command !== "string") {
+        return false;
+    }
+    const notification = hooks.Notification;
+    if (notification !== undefined && !Array.isArray(notification)) {
+        return false;
+    }
+    const preToolUse = hooks.PreToolUse;
+    return preToolUse === undefined || Array.isArray(preToolUse);
+};
+const readClaudeSettings = async (templatePath) => {
+    const templateRaw = await readFile(templatePath, "utf8");
+    const parsed = JSON.parse(templateRaw);
+    if (!isClaudeSettings(parsed)) {
+        throw new Error("Claude settings template has an invalid shape.");
+    }
+    return parsed;
+};
+const mergeStringArrays = (left = [], right = []) => Array.from(new Set([...left, ...right]));
+const upsertHookMatcherEntry = (entries, matcher, command) => {
+    const nextEntries = [...(entries ?? [])];
+    const existingIndex = nextEntries.findIndex((entry) => (entry.matcher ?? "") === matcher);
+    const hook = { type: "command", command };
+    if (existingIndex === -1) {
+        nextEntries.push({ matcher, hooks: [hook] });
+        return nextEntries;
+    }
+    const existingEntry = nextEntries[existingIndex];
+    nextEntries[existingIndex] = { ...existingEntry, hooks: [hook] };
+    return nextEntries;
+};
+const mergeClaudeSettings = (existingSettings, baseSettings, packagePath) => {
+    const notificationCommand = `${packagePath}/.claude/hooks/notification.sh`;
+    const protectFilesCommand = `${packagePath}/.claude/hooks/protect-files.sh`;
+    const statusLineCommand = `node ${packagePath}/.claude/hooks/status-line/index.js`;
+    return {
+        ...existingSettings,
+        $schema: baseSettings.$schema ?? existingSettings.$schema,
+        attribution: { ...(baseSettings.attribution ?? {}), ...(existingSettings.attribution ?? {}) },
+        permissions: {
+            ...(existingSettings.permissions ?? {}),
+            ...(baseSettings.permissions ?? {}),
+            ask: mergeStringArrays(baseSettings.permissions?.ask, existingSettings.permissions?.ask),
+            deny: mergeStringArrays(baseSettings.permissions?.deny, existingSettings.permissions?.deny),
+        },
+        hooks: {
+            ...existingSettings.hooks,
+            Notification: upsertHookMatcherEntry(existingSettings.hooks.Notification, "", notificationCommand),
+            PreToolUse: upsertHookMatcherEntry(existingSettings.hooks.PreToolUse, "Edit|Write", protectFilesCommand),
+        },
+        statusLine: {
+            ...existingSettings.statusLine,
+            ...baseSettings.statusLine,
+            type: "command",
+            command: statusLineCommand,
+        },
+    };
+};
+export const renderClaude = async (targetDir, force, packageRoot) => {
+    const templatePath = path.join(packageRoot, "claude/.claude/settings.base.json");
+    const baseSettings = await readClaudeSettings(templatePath);
+    const packagePath = "./node_modules/pasika/claude";
+    const notificationEntries = upsertHookMatcherEntry(baseSettings.hooks.Notification, "", `${packagePath}/.claude/hooks/notification.sh`);
+    const preToolUseEntries = upsertHookMatcherEntry(baseSettings.hooks.PreToolUse, "Edit|Write", `${packagePath}/.claude/hooks/protect-files.sh`);
+    const settings = {
+        ...baseSettings,
+        hooks: {
+            ...baseSettings.hooks,
+            Notification: notificationEntries,
+            PreToolUse: preToolUseEntries,
+        },
+        statusLine: {
+            ...baseSettings.statusLine,
+            type: "command",
+            command: `node ${packagePath}/.claude/hooks/status-line/index.js`,
+        },
+    };
+    const outputDir = path.join(targetDir, ".claude");
+    const outputPath = path.join(outputDir, "settings.json");
+    await mkdir(outputDir, { recursive: true });
+    const finalSettings = !force && (await fileExists(outputPath))
+        ? mergeClaudeSettings(await readClaudeSettings(outputPath), settings, packagePath)
+        : settings;
+    await writeFile(outputPath, `${JSON.stringify(finalSettings, null, 2)}\n`, "utf8");
+    return [outputPath];
+};
+const isDirectRun = process.argv[1] ? path.resolve(process.argv[1]) === __filename : false;
+if (isDirectRun) {
+    const args = process.argv.slice(2);
+    const getArgValue = (flag) => {
+        const index = args.indexOf(flag);
+        if (index === -1) {
+            return undefined;
+        }
+        return args[index + 1];
+    };
+    const targetDir = path.resolve(process.cwd(), getArgValue("--target-dir") ?? ".");
+    const force = args.includes("--force");
+    const packageRoot = path.resolve(__dirname, "../..");
+    try {
+        const outputs = await renderClaude(targetDir, force, packageRoot);
+        for (const output of outputs) {
+            process.stdout.write(`Wrote ${output}\n`);
+        }
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    }
+}

package/dist/eslint.config.js

@@ -0,0 +1,7 @@
+import { RuleSeverity, styleguide } from "zirka";
+const { eslintConfig } = styleguide({
+    node: RuleSeverity.Error,
+    typescript: RuleSeverity.Error,
+    ignores: ["dist/**", "node_modules/**", "prettier.config.mjs"],
+});
+export default eslintConfig;

package/dist/scripts/pasika.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { renderClaude } from "../claude/scripts/render-settings.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.basename(path.dirname(__dirname)) === "dist" ? path.resolve(__dirname, "../..") : path.resolve(__dirname, "..");
+const args = process.argv.slice(2);
+const helpText = `pasika
+
+Usage:
+  pasika claude [--target-dir <path>] [--force]
+
+Platforms:
+  claude
+
+Examples:
+  npx pasika claude
+  npx pasika claude --force
+
+Behavior:
+  merges into existing .claude/settings.json by default
+  replaces it only when --force is passed
+`;
+const getFlagValue = (flag) => {
+    const index = args.indexOf(flag);
+    if (index === -1) {
+        return undefined;
+    }
+    return args[index + 1];
+};
+const hasFlag = (flag) => args.includes(flag);
+const platform = args[0];
+if (!platform || hasFlag("--help") || hasFlag("-h")) {
+    process.stdout.write(helpText);
+    process.exit(platform ? 0 : 1);
+}
+const targetDir = path.resolve(process.cwd(), getFlagValue("--target-dir") ?? ".");
+const force = hasFlag("--force");
+const run = async () => {
+    switch (platform) {
+        case "claude":
+            return renderClaude(targetDir, force, packageRoot);
+        default:
+            throw new Error(`Unknown platform: ${platform}`);
+    }
+};
+try {
+    const outputs = await run();
+    process.stdout.write(`Initialized ${platform} in ${targetDir}\n`);
+    for (const output of outputs) {
+        process.stdout.write(`Wrote ${output}\n`);
+    }
+}
+catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.stderr.write(helpText);
+    process.exit(1);
+}

package/docs/claude/hooks.md

@@ -0,0 +1,30 @@
+# Claude Hooks
+
+`pasika` ships the reusable shared Claude hooks.
+
+## `status-line/index.js`
+
+Displays a two-line status view with:
+
+- model name
+- current folder
+- git branch when available
+- used context percentage as a 10-segment bar
+- session cost
+- session duration
+
+## `notification.sh`
+
+Sends a desktop notification when Claude needs attention.
+
+- macOS: `terminal-notifier` with click-to-focus VS Code behavior, falls back to `osascript`
+- Linux: `notify-send`
+- Windows: PowerShell message box
+
+## `protect-files.sh`
+
+Blocks edits to:
+
+- `.env` files
+- `package-lock.json`
+- files inside `.git/`

package/docs/common/merge-behavior.md

@@ -0,0 +1,17 @@
+# Merge Behavior
+
+`pasika` merges into an existing `.claude/settings.json` by default.
+
+It updates the Claude base pieces owned by `pasika`:
+
+- `hooks.Notification`
+- `hooks.PreToolUse`
+- `statusLine`
+
+It preserves unrelated project-specific settings such as:
+
+- custom permissions
+- extra hooks like `PostToolUse`
+- plugin and marketplace config
+
+Use `--force` only when you want to replace the file instead of merging.

package/docs/common/overview.md

@@ -0,0 +1,20 @@
+# pasika
+
+`pasika` is a reusable Claude Code base package.
+
+## Scope
+
+- Claude only for v1
+- shared hooks and base settings
+- merge-friendly project integration
+- no project-specific skills, rules, or plugin choices
+
+## Usage
+
+Install `pasika` as a dev dependency, then run:
+
+```bash
+npx pasika claude
+```
+
+That generates or updates `.claude/settings.json` to point shared hooks at `./node_modules/pasika/claude/...`.

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "pasika",
+  "version": "0.1.0",
+  "description": "Reusable Claude Code base config package",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf dist AGENTS.md CLAUDE.md && tsc -p tsconfig.json && npx vulyk docs",
+    "check": "npm run lint && npm run typecheck",
+    "fix": "eslint . --fix",
+    "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "bin": {
+    "pasika": "dist/scripts/pasika.js"
+  },
+  "files": [
+    "claude",
+    "docs",
+    "dist",
+    "AGENTS.md",
+    "CLAUDE.md",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.12.2",
+    "eslint": "^9.39.4",
+    "prettier": "^3.8.1",
+    "typescript": "^5.9.2",
+    "vulyk": "^0.6.1",
+    "zirka": "^0.0.28"
+  }
+}