akademia 0.0.1 → 0.1.1

package/README.md

@@ -1,9 +1,42 @@
-# akademia
+# Akademia CLI
 
-Minimalny pakiet Akademia.pl zabezpieczający nazwę w rejestrze npm.
-Pełna biblioteka i API pojawią się wraz ze startem produktu w kwietniu 2026.
+Prosty dostęp do publicznych promptów i checklist Akademia.pl z terminala.
 
-```js
-const akademia = require('akademia');
-console.log(akademia());
+## Instalacja
+
+```bash
+npm install -g akademia
+akademia
+```
+
+Po instalacji wpisz:
+
+```bash
+akademia pomoc
+```
+
+## Podstawowe użycie
+
+```bash
+akademia szukaj "landing page"
+akademia pokaz wywiad-przed-startem-projektu
+akademia status
+```
+
+## Prywatność
+
+CLI V1 pobiera tylko publiczne pliki JSON. Nie wysyła kodu projektu, plików, maili ani danych klientów do Akademii.
+
+## API
+
+Domyślnie CLI łączy się z:
+
+```bash
+https://akademia.pl
+```
+
+Technicznie możesz podmienić endpoint:
+
+```bash
+AKADEMIA_API_BASE=http://127.0.0.1:8898 akademia status
 ```

package/bin/akademia.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import { AkademiaClient } from "../src/client.js";
+import { writeReport } from "../src/report.js";
+import { scanProject } from "../src/scan.js";
+import { searchResources } from "../src/search.js";
+import { printDoctor, printResource, printScanResults, printSearchResults } from "../src/format.js";
+
+const VERSION = "0.1.1";
+
+async function main(argv) {
+  const { command, args, flags } = parseArgs(argv);
+  const client = new AkademiaClient({ baseUrl: flags.baseUrl });
+
+  if (flags.version) {
+    console.log(VERSION);
+    return;
+  }
+
+  if (flags.help || isHelpCommand(command)) {
+    printHelp();
+    return;
+  }
+
+  if (!command) {
+    await printStart(client);
+    return;
+  }
+
+  const action = normalizeCommand(command);
+
+  if (action === "doctor") {
+    const catalog = await client.catalog();
+    printDoctor(catalog, client.baseUrl);
+    return;
+  }
+
+  if (action === "search") {
+    const query = args.join(" ").trim();
+    if (!query) throw new Error("Podaj frazę, np. akademia szukaj \"landing page\".");
+    const index = await client.searchIndex();
+    const results = searchResources(index, query, {
+      limit: flags.limit || 10,
+      type: flags.type
+    });
+    printSearchResults(results);
+    return;
+  }
+
+  if (action === "show") {
+    const id = args[0];
+    if (!id) throw new Error("Podaj ID zasobu, np. akademia pokaz wywiad-przed-startem-projektu.");
+    const resource = await client.resource(id);
+    printResource(resource, { full: flags.full });
+    return;
+  }
+
+  if (action === "scan") {
+    const target = args[0] || ".";
+    const index = await client.searchIndex();
+    const result = await scanProject(target, index, {
+      limit: flags.limit || 12,
+      maxFiles: flags.maxFiles || 250
+    });
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printScanResults(result);
+    return;
+  }
+
+  if (action === "report") {
+    const target = args[0] || ".";
+    const index = await client.searchIndex();
+    const result = await scanProject(target, index, {
+      limit: flags.limit || 12,
+      maxFiles: flags.maxFiles || 250
+    });
+    const outputPath = await writeReport(result, { out: flags.out });
+    console.log(`Raport zapisany: ${outputPath}`);
+    console.log(`Znaleziska: ${result.findings.length}`);
+    return;
+  }
+
+  throw new Error(`Nie znam tej komendy. Wpisz: akademia pomoc`);
+}
+
+function parseArgs(argv) {
+  const args = [];
+  const flags = {};
+  let command = "";
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (!command && !value.startsWith("-")) {
+      command = value;
+      continue;
+    }
+    if (value === "--help" || value === "-h") {
+      flags.help = true;
+      continue;
+    }
+    if (value === "--version" || value === "-v") {
+      flags.version = true;
+      continue;
+    }
+    if (value === "--full") {
+      flags.full = true;
+      continue;
+    }
+    if (value === "--json") {
+      flags.json = true;
+      continue;
+    }
+    if (value === "--type") {
+      flags.type = argv[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (value === "--limit") {
+      flags.limit = Number(argv[index + 1] || 10);
+      index += 1;
+      continue;
+    }
+    if (value === "--max-files") {
+      flags.maxFiles = Number(argv[index + 1] || 250);
+      index += 1;
+      continue;
+    }
+    if (value === "--out") {
+      flags.out = argv[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (value === "--base-url") {
+      flags.baseUrl = argv[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    args.push(value);
+  }
+
+  return { command, args, flags };
+}
+
+function normalizeCommand(command) {
+  const commands = new Map([
+    ["doctor", "doctor"],
+    ["status", "doctor"],
+    ["search", "search"],
+    ["szukaj", "search"],
+    ["show", "show"],
+    ["pokaz", "show"],
+    ["pokaż", "show"],
+    ["scan", "scan"],
+    ["report", "report"]
+  ]);
+
+  return commands.get(command) || command;
+}
+
+function isHelpCommand(command) {
+  return command === "help" || command === "pomoc";
+}
+
+async function printStart(client) {
+  try {
+    const catalog = await client.catalog();
+    const resources = catalog?.resources || [];
+    const total = resources.length;
+    const prompts = resources.filter((item) => item.type === "prompt").length;
+    const checklists = resources.filter((item) => item.type === "checklist").length;
+
+    console.log(`Akademia.pl CLI ${VERSION}
+
+Łączy terminal z publicznymi promptami i checklistami Akademii.
+
+Status: działa
+Zasoby: ${total} publicznych materiałów, ${prompts} promptów, ${checklists} checklist
+
+Następny krok:
+  akademia pomoc
+`);
+    return;
+  } catch (error) {
+    console.log(`Akademia.pl CLI ${VERSION}
+
+CLI jest zainstalowane, ale nie udało się połączyć z Akademia.pl.
+
+Następny krok:
+  akademia pomoc
+
+Szczegół techniczny: ${error.message}
+`);
+  }
+}
+
+function printHelp() {
+  console.log(`Akademia.pl CLI ${VERSION}
+
+Najprościej:
+  akademia
+
+Szukaj promptu albo checklisty:
+  akademia szukaj "landing page"
+
+Pokaż konkretny materiał:
+  akademia pokaz wywiad-przed-startem-projektu
+
+Sprawdź połączenie:
+  akademia status
+`);
+}
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(`Błąd: ${error.message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -1,16 +1,28 @@
 {
   "name": "akademia",
-  "version": "0.0.1",
-  "description": "Pakiet placeholder Akademia.pl – rezerwacja nazwy.",
-  "main": "index.js",
+  "version": "0.1.1",
+  "description": "CLI Akademia.pl do lokalnego dostępu do promptów i checklist.",
+  "type": "module",
+  "bin": {
+    "akademia": "bin/akademia.js"
+  },
   "files": [
-    "index.js"
+    "bin",
+    "src",
+    "README.md"
   ],
-  "keywords": [
-    "akademia",
-    "aibl",
-    "skills"
-  ],
-  "author": "Mirek Burnejko",
-  "license": "MIT"
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "check": "node --check bin/akademia.js && node --check src/client.js && node --check src/search.js && node --check src/format.js && node --check src/scan.js && node --check src/report.js",
+    "doctor": "node bin/akademia.js doctor",
+    "search": "node bin/akademia.js search",
+    "show": "node bin/akademia.js show",
+    "scan": "node bin/akademia.js scan",
+    "report": "node bin/akademia.js report"
+  }
 }

package/src/client.js

@@ -0,0 +1,57 @@
+const DEFAULT_BASE_URL = "https://akademia.pl";
+
+export function resolveBaseUrl(value = process.env.AKADEMIA_API_BASE) {
+  const raw = String(value || DEFAULT_BASE_URL).trim().replace(/\/+$/, "");
+  if (!raw) return DEFAULT_BASE_URL;
+  try {
+    const url = new URL(raw);
+    if (!["http:", "https:"].includes(url.protocol)) {
+      throw new Error("invalid protocol");
+    }
+    return url.toString().replace(/\/+$/, "");
+  } catch {
+    throw new Error(`Nieprawidłowy AKADEMIA_API_BASE: ${raw}`);
+  }
+}
+
+export class AkademiaClient {
+  constructor(options = {}) {
+    this.baseUrl = resolveBaseUrl(options.baseUrl);
+  }
+
+  async catalog() {
+    return this.getJson("/api/v1/catalog.json");
+  }
+
+  async searchIndex() {
+    return this.getJson("/api/v1/search-index.json");
+  }
+
+  async resource(id) {
+    const safeId = sanitizeResourceId(id);
+    if (!safeId) throw new Error("Podaj poprawne ID zasobu.");
+    return this.getJson(`/api/v1/resources/${safeId}.json`);
+  }
+
+  async getJson(path) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "akademia-cli/0.1"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`API zwróciło ${response.status} dla ${url}`);
+    }
+    return response.json();
+  }
+}
+
+export function sanitizeResourceId(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, "")
+    .slice(0, 160);
+}

package/src/format.js

@@ -0,0 +1,106 @@
+export function printDoctor(catalog, baseUrl) {
+  const meta = catalog.meta || {};
+  const resources = catalog.resources || [];
+  const prompts = resources.filter((item) => item.type === "prompt").length;
+  const checklists = resources.filter((item) => item.type === "checklist").length;
+  const security = meta.security || {};
+  const connection = resources.length ? "działa" : "brak publicznych zasobów";
+
+  console.log("Akademia.pl CLI");
+  console.log(`Status: ${connection}`);
+  console.log(`API: ${baseUrl}`);
+  console.log(`Zasoby: ${resources.length} publicznych materiałów`);
+  console.log(`Prompty: ${prompts}`);
+  console.log(`Checklisty: ${checklists}`);
+  console.log(`Pliki z Twojego komputera: ${security.acceptsProjectFiles ? "wysyłane" : "nie są wysyłane"}`);
+}
+
+export function printSearchResults(results) {
+  if (!results.length) {
+    console.log("Brak wyników.");
+    return;
+  }
+
+  for (const [index, item] of results.entries()) {
+    console.log(`${index + 1}. ${item.title}`);
+    console.log(`   id: ${item.id}`);
+    console.log(`   typ: ${item.type}, zastosowanie: ${item.application || item.applicationSlug || "brak"}`);
+    console.log(`   opis: ${item.description || item.seoDescription || ""}`);
+    console.log(`   score: ${item.score}`);
+  }
+}
+
+export function printResource(resource, options = {}) {
+  console.log(`${resource.title}`);
+  console.log(`id: ${resource.id}`);
+  console.log(`typ: ${resource.type}`);
+  console.log(`url: https://akademia.pl${resource.url || ""}`);
+  if (resource.description) console.log(`opis: ${resource.description}`);
+  if (resource.usage) {
+    console.log("");
+    console.log("Jak użyć:");
+    console.log(wrap(resource.usage));
+  }
+
+  const content = resource.prompt || checklistText(resource);
+  if (content) {
+    console.log("");
+    console.log(resource.prompt ? "Prompt:" : "Checklista:");
+    console.log(options.full ? content : truncate(content, 1800));
+  }
+}
+
+export function printScanResults(result) {
+  console.log("Skan Akademii");
+  console.log(`Projekt: ${result.root}`);
+  console.log(`Przeczytane pliki: ${result.scannedFiles}`);
+  console.log(`Znaleziska: ${result.findings.length}`);
+
+  if (!result.findings.length) {
+    console.log("");
+    console.log("Brak znalezisk z dowodem w plikach.");
+    return;
+  }
+
+  for (const [index, item] of result.findings.entries()) {
+    console.log("");
+    console.log(`${index + 1}. ${item.area}`);
+    console.log(`Znalezisko: ${item.finding}`);
+    console.log(`Dowód: ${item.evidence.file}:${item.evidence.line}`);
+    console.log(`Fragment: ${item.evidence.text}`);
+    console.log(`Ryzyko: ${item.risk}`);
+    console.log(`Priorytet: ${item.priority || "brak"}`);
+    console.log(`Wysiłek: ${item.effort || "brak"}`);
+    if (item.recommendedResource) {
+      console.log(`Zasób Akademii: ${item.recommendedResource.title}`);
+      console.log(`ID zasobu: ${item.recommendedResource.id}`);
+    } else {
+      console.log("Zasób Akademii: brak dopasowania");
+    }
+    console.log(`Pierwsze 15 minut: ${item.action}`);
+    console.log(`Test jakości: ${item.qualityTest || "brak"}`);
+  }
+}
+
+function checklistText(resource) {
+  if (Array.isArray(resource.checklist)) return resource.checklist.map((item) => `- ${item}`).join("\n");
+  if (Array.isArray(resource.checklistSections)) {
+    return resource.checklistSections
+      .map((section) => {
+        const items = (section.items || []).map((item) => `- ${item}`).join("\n");
+        return `${section.title || "Sekcja"}\n${items}`;
+      })
+      .join("\n\n");
+  }
+  return "";
+}
+
+function truncate(value, maxLength) {
+  const text = String(value || "");
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength).trim()}\n\n[ucięte, użyj --full żeby zobaczyć całość]`;
+}
+
+function wrap(value) {
+  return String(value || "").trim();
+}

package/src/report.js

@@ -0,0 +1,60 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export async function writeReport(result, options = {}) {
+  const outputPath = path.resolve(process.cwd(), options.out || "akademia-report.md");
+  await mkdir(path.dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, renderReportMarkdown(result), "utf8");
+  return outputPath;
+}
+
+export function renderReportMarkdown(result) {
+  const lines = [
+    "# Raport Akademii",
+    "",
+    `Projekt: ${result.root}`,
+    `Przeczytane pliki: ${result.scannedFiles}`,
+    `Znaleziska: ${result.findings.length}`,
+    ""
+  ];
+
+  if (!result.findings.length) {
+    lines.push("Brak znalezisk z dowodem w plikach.");
+    lines.push("");
+    return lines.join("\n");
+  }
+
+  result.findings.forEach((item, index) => {
+    lines.push(`## ${index + 1}. ${item.area}`);
+    lines.push("");
+    lines.push(`Znalezisko: ${item.finding}`);
+    lines.push("");
+    lines.push(`Dowód: ${item.evidence.file}:${item.evidence.line}`);
+    lines.push("");
+    lines.push("Fragment:");
+    lines.push("");
+    lines.push("```text");
+    lines.push(item.evidence.text);
+    lines.push("```");
+    lines.push("");
+    lines.push(`Ryzyko biznesowe: ${item.risk}`);
+    lines.push("");
+    lines.push(`Priorytet: ${item.priority || "brak"}`);
+    lines.push(`Wysiłek: ${item.effort || "brak"}`);
+    lines.push("");
+    if (item.recommendedResource) {
+      lines.push(`Rekomendowany zasób Akademii: ${item.recommendedResource.title}`);
+      lines.push(`ID zasobu: ${item.recommendedResource.id}`);
+      lines.push(`Typ zasobu: ${item.recommendedResource.type}`);
+      lines.push(`URL: https://akademia.pl${item.recommendedResource.url || ""}`);
+    } else {
+      lines.push("Rekomendowany zasób Akademii: brak dopasowania");
+    }
+    lines.push("");
+    lines.push(`Pierwsze 15 minut pracy: ${item.action}`);
+    lines.push(`Test jakości: ${item.qualityTest || "brak"}`);
+    lines.push("");
+  });
+
+  return lines.join("\n");
+}

package/src/scan.js

@@ -0,0 +1,276 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { searchResources } from "./search.js";
+
+const DEFAULT_MAX_FILES = 250;
+const MAX_FILE_BYTES = 120000;
+const MAX_FINDINGS_PER_AREA = 1;
+
+const IGNORED_DIRS = new Set([
+  ".cache",
+  ".git",
+  ".next",
+  ".serverless",
+  ".turbo",
+  "backups",
+  "build",
+  "coverage",
+  "dist",
+  "golden",
+  "node_modules",
+  "tmp",
+  "TMP",
+  "vendor"
+]);
+
+const IGNORED_FILES = new Set([
+  ".DS_Store",
+  ".env",
+  ".env.local",
+  ".env.production",
+  "akademia-report.md",
+  "CHANGELOG.md",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock"
+]);
+
+const TEXT_EXTENSIONS = new Set([
+  ".css",
+  ".html",
+  ".js",
+  ".json",
+  ".jsx",
+  ".md",
+  ".mdx",
+  ".mjs",
+  ".ts",
+  ".tsx",
+  ".txt",
+  ".yaml",
+  ".yml"
+]);
+
+const AREAS = [
+  {
+    id: "start-projektu",
+    area: "Start projektu",
+    query: "wywiad przed startem projektu brief decyzja",
+    preferredResourceId: "wywiad-przed-startem-projektu",
+    pattern: /\b(mvp|roadmap|sprint|start projektu|scope|zakres|todo|tbd|wip|decyzja)\b/i,
+    finding: "Projekt ma miejsce, które warto doprecyzować przed dalszą pracą.",
+    risk: "Bez mocnego briefu agent może optymalizować zadania zamiast właściwej decyzji biznesowej.",
+    action: "Zbierz cel, odbiorcę, miernik sukcesu, zakres poza projektem i warunek stop.",
+    priority: "średni",
+    effort: "30 do 60 minut",
+    qualityTest: "Po poprawce projekt ma cel, właściciela, miernik sukcesu, zakres poza projektem i warunek stop."
+  },
+  {
+    id: "strona-i-konwersja",
+    area: "Strona i konwersja",
+    query: "landing page lead magnet thank you copywriting strona sprzedażowa",
+    preferredResourceId: "lead-magnet-popup-thank-you-page",
+    pattern: /\b(landing|hero|cta|lead magnet|newsletter|formularz|zapis|popup|thank you|strona sprzedażowa|checkout)\b/i,
+    finding: "W projekcie jest powierzchnia konwersji, którą warto sprawdzić checklistą.",
+    risk: "Strona może zbierać ruch, ale gubić jasną obietnicę, CTA albo następny krok użytkownika.",
+    action: "Sprawdź nagłówek, obietnicę, formularz, CTA, dowody społeczne i stronę po zapisie.",
+    priority: "wysoki",
+    effort: "45 do 90 minut",
+    qualityTest: "Po poprawce użytkownik rozumie obietnicę, widzi jedno główne CTA i wie, co stanie się po kliknięciu."
+  },
+  {
+    id: "oferta-i-sprzedaz",
+    area: "Oferta i sprzedaż",
+    query: "copywriting oferta pricing sprzedaż negocjacje rezultaty zamiast funkcji",
+    preferredResourceId: "oferta-b2b-do-100k-pln",
+    pattern: /\b(oferta|cennik|pricing|sprzedaż|sprzedaz|rabat|usługa|usluga|kup|demo)\b/i,
+    finding: "Projekt dotyka oferty albo sprzedaży i warto przejść z funkcji na rezultat.",
+    risk: "Komunikacja może opisywać produkt, ale nie pokazywać powodu zakupu i kryterium decyzji.",
+    action: "Przepisz kluczowe sekcje na rezultat, obiekcje, dowody, zakres i warunki decyzji.",
+    priority: "wysoki",
+    effort: "60 do 120 minut",
+    qualityTest: "Po poprawce oferta ma wynik dla klienta, cenę albo zakres, wyłączenia, dowody i jasny kolejny krok."
+  },
+  {
+    id: "marketing-i-research",
+    area: "Marketing i research",
+    query: "strategia marketingowa deep research persona kampania content",
+    preferredResourceId: "badania-psychograficzne-deep-research",
+    pattern: /\b(persona|icp|kampania|content|seo|linkedin|meta ads|research|rynek|segment|grupa docelowa)\b/i,
+    finding: "W projekcie jest marketing albo research, który może wymagać mocniejszego kontekstu rynku.",
+    risk: "Agent może pisać treści bez języka klienta, obiekcji, alternatyw i realnych triggerów zakupu.",
+    action: "Zbierz język rynku, pytania, obiekcje, konkurencję, kanały i hipotezy do testu.",
+    priority: "średni",
+    effort: "60 do 120 minut",
+    qualityTest: "Po poprawce materiał zawiera język klienta, obiekcje, alternatywy, trigger zakupu i hipotezę do sprawdzenia."
+  },
+  {
+    id: "proces-i-crm",
+    area: "Proces i CRM",
+    query: "workflow proces guard system follow up onboarding",
+    preferredResourceId: "wnioski-z-dyskusji-do-poprawy-systemu",
+    pattern: /\b(follow up|pipeline|deal|onboarding|renewal|mailing)\b|\bcrm\b.*\b(proces|pipeline|follow|sprzedaż|sprzedaz|segment|mailing)\b|\b(proces|pipeline|follow|sprzedaż|sprzedaz|segment|mailing)\b.*\bcrm\b/i,
+    finding: "Projekt ma proces sprzedaży, obsługi albo CRM, który warto sprawdzić operacyjnie.",
+    risk: "Bez procesu i statusów łatwo zgubić odpowiedzialność, follow up albo sygnał do decyzji.",
+    action: "Nazwij etapy, właściciela, trigger, następny krok, status i minimalny log decyzji.",
+    priority: "średni",
+    effort: "45 do 90 minut",
+    qualityTest: "Po poprawce proces ma etapy, właściciela, trigger wejścia, następny krok i status końcowy."
+  },
+  {
+    id: "bezpieczenstwo-i-api",
+    area: "Bezpieczeństwo i API",
+    query: "api bezpieczeństwo code review",
+    preferredResourceId: "agent-team-code-review",
+    pattern: /\b(api|token|secret|auth|waf|rate limit|rodo|privacy|dane|hasło|hasla|webhook)\b/i,
+    finding: "Projekt dotyka API, danych albo dostępu i wymaga prostego przeglądu bezpieczeństwa.",
+    risk: "Niewidoczne założenia o dostępie, limitach i danych mogą później stać się incydentem.",
+    action: "Sprawdź dane wejściowe, limity, sekrety, logi, retencję, auth i komunikat dla użytkownika.",
+    priority: "wysoki",
+    effort: "60 do 120 minut",
+    qualityTest: "Po poprawce wiadomo, jakie dane wchodzą do systemu, gdzie są limity, gdzie jest auth i czego nie logujemy."
+  }
+];
+
+export async function scanProject(target, resourceIndex, options = {}) {
+  const root = path.resolve(process.cwd(), target || ".");
+  const maxFiles = Number(options.maxFiles || DEFAULT_MAX_FILES);
+  const files = await collectFiles(root, { maxFiles });
+  const findings = [];
+
+  for (const file of files) {
+    const lines = await readInterestingLines(file, root);
+    for (const line of lines) {
+      for (const area of AREAS) {
+        if (!area.pattern.test(line.text)) continue;
+        if (countArea(findings, area.id) >= MAX_FINDINGS_PER_AREA) continue;
+        findings.push(buildFinding(area, line, resourceIndex));
+      }
+    }
+  }
+
+  return {
+    root,
+    scannedFiles: files.length,
+    findings: dedupeFindings(findings).slice(0, Number(options.limit || 12))
+  };
+}
+
+async function collectFiles(root, options) {
+  const files = [];
+
+  async function walk(current) {
+    if (files.length >= options.maxFiles) return;
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      if (files.length >= options.maxFiles) return;
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!shouldSkipDir(entry.name)) await walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || shouldSkipFile(entry.name)) continue;
+      const info = await stat(fullPath);
+      if (info.size > MAX_FILE_BYTES || !isTextFile(fullPath)) continue;
+      files.push(fullPath);
+    }
+  }
+
+  await walk(root);
+  return files;
+}
+
+function shouldSkipDir(name) {
+  return IGNORED_DIRS.has(name) || name.startsWith(".");
+}
+
+function shouldSkipFile(name) {
+  if (IGNORED_FILES.has(name)) return true;
+  if (name.endsWith(".pem") || name.endsWith(".key") || name.endsWith(".crt")) return true;
+  return false;
+}
+
+function isTextFile(filePath) {
+  return TEXT_EXTENSIONS.has(path.extname(filePath));
+}
+
+async function readInterestingLines(filePath, root) {
+  const text = await readFile(filePath, "utf8");
+  return text
+    .split(/\r?\n/)
+    .map((textLine, index) => ({
+      file: path.relative(root, filePath) || path.basename(filePath),
+      line: index + 1,
+      text: cleanLine(textLine)
+    }))
+    .filter((line) => line.text.length >= 8 && line.text.length <= 220)
+    .filter((line) => isUsefulEvidenceLine(line.text));
+}
+
+function buildFinding(area, line, resourceIndex) {
+  const resource = findPreferredResource(resourceIndex, area) || searchResources(resourceIndex, area.query, { limit: 1 })[0];
+  return {
+    areaId: area.id,
+    area: area.area,
+    finding: area.finding,
+    evidence: line,
+    risk: area.risk,
+    priority: area.priority,
+    effort: area.effort,
+    recommendedResource: resource ? {
+      id: resource.id,
+      title: resource.title,
+      type: resource.type,
+      url: resource.url
+    } : null,
+    action: area.action,
+    qualityTest: area.qualityTest
+  };
+}
+
+function findPreferredResource(resourceIndex, area) {
+  if (!area.preferredResourceId) return null;
+  return resourceIndex.find((item) => item.id === area.preferredResourceId) || null;
+}
+
+function countArea(findings, areaId) {
+  return findings.filter((item) => item.areaId === areaId).length;
+}
+
+function dedupeFindings(findings) {
+  const seen = new Set();
+  const result = [];
+  for (const finding of findings) {
+    const key = `${finding.evidence.file}:${finding.evidence.line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(finding);
+  }
+  return result;
+}
+
+function cleanLine(value) {
+  return String(value || "")
+    .replace(/\s+/g, " ")
+    .replace(/[ \t]+$/g, "")
+    .trim();
+}
+
+function isUsefulEvidenceLine(value) {
+  if (/^\s*(area|id|query|pattern|finding|risk|action|priority|effort|qualityTest|preferredResourceId):/i.test(value)) return false;
+  if (/^"(id|slug|title|type|url|applicationSlug|applicationSlugs|industrySlug|industrySlugs|canonicalCluster|intent|keywords|tags)":/i.test(value)) return false;
+  if (/^"(draft_not_contains|finding_contains|finding_not_contains|expected|actual)":/i.test(value)) return false;
+  if (/^<meta\b/i.test(value) || /<meta\s/i.test(value)) return false;
+  if (/\bclass="/i.test(value) && !/>[^<]{12,}</.test(value)) return false;
+  if (/^\.[a-z0-9_-]+\s*\{/i.test(value)) return false;
+  if (/^content-type:/i.test(value)) return false;
+  if (/^[a-z0-9_.-]+==\d/i.test(value)) return false;
+  if (/\b(cookie|pliki cookie)\b/i.test(value)) return false;
+  if (/\bFIXED\b/i.test(value) || /^\s*[-*]\s*\[x\]/i.test(value)) return false;
+  if (/\b(tokens|fonts|components|pages\/\*)\b/i.test(value) && /\.(css|js|jsx|ts|tsx|html|md|json)\b/i.test(value)) return false;
+  if (/\bCSS\s*(→|->)\b/i.test(value) || /\btokens,\s*fonts,\s*core,\s*components\b/i.test(value)) return false;
+  if (/^\|[^|]+\|[^|]+\|$/.test(value) && value.length < 90) return false;
+  if (value.includes("\\b(") || value.includes("RegExp")) return false;
+  if (value.startsWith("const ") || value.startsWith("let ") || value.startsWith("function ")) return false;
+  return true;
+}

package/src/search.js

@@ -0,0 +1,59 @@
+const TYPE_WEIGHT = 8;
+const TITLE_WEIGHT = 12;
+const KEYWORD_WEIGHT = 10;
+const TAG_WEIGHT = 6;
+const TEXT_WEIGHT = 1;
+
+export function searchResources(index, query, options = {}) {
+  const terms = tokenize(query);
+  const type = options.type ? String(options.type).toLowerCase() : "";
+  const limit = Number(options.limit || 10);
+  if (!terms.length) return [];
+
+  return index
+    .filter((item) => !type || item.type === type)
+    .map((item) => ({ item, score: scoreItem(item, terms) }))
+    .filter((result) => result.score > 0)
+    .sort((a, b) => b.score - a.score || a.item.title.localeCompare(b.item.title, "pl"))
+    .slice(0, limit)
+    .map((result) => ({
+      ...result.item,
+      score: result.score
+    }));
+}
+
+export function tokenize(value) {
+  return String(value || "")
+    .toLowerCase()
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .split(/[^a-z0-9]+/)
+    .map((term) => term.trim())
+    .filter((term) => term.length >= 2);
+}
+
+function scoreItem(item, terms) {
+  const title = normalize(item.title);
+  const type = normalize(item.type);
+  const keywords = normalize((item.keywords || []).join(" "));
+  const tags = normalize((item.tags || []).join(" "));
+  const text = normalize(item.text || "");
+  let score = 0;
+
+  for (const term of terms) {
+    if (type === term) score += TYPE_WEIGHT;
+    if (title.includes(term)) score += TITLE_WEIGHT;
+    if (keywords.includes(term)) score += KEYWORD_WEIGHT;
+    if (tags.includes(term)) score += TAG_WEIGHT;
+    if (text.includes(term)) score += TEXT_WEIGHT;
+  }
+
+  return score;
+}
+
+function normalize(value) {
+  return String(value || "")
+    .toLowerCase()
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "");
+}

package/index.js

@@ -1,3 +0,0 @@
-module.exports = function () {
-  return "Akademia – start produktu w kwietniu 2026. Więcej na akademia.pl";
-};