kc-beta 0.6.1 → 0.7.0

package/LICENSE

@@ -0,0 +1,81 @@
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose.  However, you may only distribute the software according to [Distribution License](#distribution-license) and make changes or new works based on the software according to [Changes and New Works License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license to distribute copies of the software.  Your license to distribute covers distributing the software with changes and new works permitted by [Changes and New Works License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above, as well as copies of any plain-text lines beginning with `Required Notice:` that the licensor provided with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to make changes and new works based on the software for any permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution is use for a permitted purpose regardless of the source of funding or obligations resulting from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else.  These terms do not imply any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice.  Otherwise, all your licenses end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.
+
+---
+
+Required Notice: Copyright (C) 2024-2026 Memium / kitchen-engineer42 (https://github.com/kitchen-engineer42/kc-cli)
+
+For commercial use (including but not limited to enterprise production
+deployment, hosting as a paid service, or distribution as a product),
+see LICENSE-COMMERCIAL.md for how to obtain a commercial license.

package/LICENSE-COMMERCIAL.md

@@ -0,0 +1,125 @@
+# Commercial License — KC Agent CLI (`kc-beta`)
+
+KC is dual-licensed:
+
+- **Noncommercial use** is governed by [LICENSE](./LICENSE) — the
+  PolyForm Noncommercial License 1.0.0. Personal users, students,
+  hobbyists, public-research organizations, charities, and government
+  institutions may use, modify, and self-host KC for free under those
+  terms.
+- **Commercial use** — including any deployment of KC inside a
+  for-profit company's production workflow, hosting KC as a paid
+  service, or redistributing KC (modified or unmodified) as part of a
+  product or service offering — is **not** covered by the
+  noncommercial license and requires a separate commercial license
+  from the rights-holder.
+
+This file describes how to obtain that commercial license.
+
+---
+
+## What counts as commercial use
+
+The PolyForm noncommercial grant covers any **noncommercial purpose**.
+The license body (LICENSE, "Personal Uses" + "Noncommercial
+Organizations" sections) defines noncommercial purposes inclusively:
+research, experiment, testing, personal study, hobby projects,
+charities, educational institutions, public research bodies, public
+safety / health bodies, environmental orgs, and government
+institutions all qualify.
+
+Anything outside that envelope is commercial use. Concrete examples
+of activities that **require** a commercial license:
+
+- Running KC inside a for-profit company's compliance, legal,
+  document-review, or audit workflow that processes business
+  documents — even for internal use.
+- Embedding KC (modified or unmodified) into a commercial product or
+  SaaS offering.
+- Hosting KC as a paid or freemium service to third parties.
+- Redistributing KC under a different name or as part of another tool
+  that is sold or monetized.
+
+Concrete examples that **do not** require a commercial license:
+
+- A developer evaluating KC at home or on a personal laptop.
+- A graduate student using KC for a thesis on regulatory NLP.
+- A nonprofit law clinic using KC to help unpaid pro-bono casework.
+- A public university research lab benchmarking LLM document
+  verification.
+- A government agency using KC for internal regulatory compliance.
+
+If you are unsure whether your use case is noncommercial, contact us
+and we will tell you in plain language. Asking is free.
+
+---
+
+## What "redistribute as a new product" forbids
+
+Both the noncommercial license and the commercial license forbid
+publishing KC's source code (or any substantial derivative) under a
+different name as a competing or independent product. The
+noncommercial license restricts derivatives to noncommercial use; the
+commercial license is non-transferable and intended for the licensee,
+not for downstream redistribution as a third-party product.
+
+Forks for the licensee's own internal use, with proper attribution
+(`Required Notice:` line preserved per the PolyForm Notices section),
+are acceptable under both licenses. Forks intended to be released as
+a new offering — paid or free — are not.
+
+---
+
+## How to obtain a commercial license
+
+Email **heavysal@gmail.com** with:
+
+1. A short description of your intended use case (industry, scale,
+   internal vs customer-facing)
+2. Your organization name and country
+3. Approximate document volume / number of users (so we can scope
+   pricing)
+4. Whether you need any specific terms (indemnification, source-code
+   escrow, on-prem only, etc.)
+
+We will respond within 5 business days with either:
+
+- A standard commercial license offer (non-negotiable terms, fixed
+  per-seat or per-document pricing — fastest path), or
+- A scoped negotiation for unusual cases (large enterprise, regulated
+  industry, special compliance requirements)
+
+Pricing for v0.7.x onward is set per inquiry. Once we have surveyed
+enough commercial licensees to set transparent rates, we will publish
+a pricing sheet here.
+
+---
+
+## Compliance for licensees
+
+A commercial license, once granted, covers the specific entity named
+in the agreement and its wholly-controlled affiliates (per PolyForm's
+"Your company" definition). It does **not** automatically extend to
+parent companies, subsidiaries with different control, or
+post-acquisition successors — those need their own license or a
+written extension.
+
+The `Required Notice: Copyright ...` line in LICENSE must remain
+present in any copies of KC the licensee distributes internally.
+
+---
+
+## Reporting violations
+
+If you believe KC is being used in violation of either license,
+please email **heavysal@gmail.com** with the relevant details. The
+PolyForm `Violations` section gives violators a 32-day correction
+window from the date of written notice; we follow that process for
+both license tracks.
+
+---
+
+*Last updated: 2026-04-29. KC v0.7.0+ is licensed under PolyForm
+Noncommercial 1.0.0 (this dual-license model). KC v0.6.x and earlier
+were licensed under MIT and remain under MIT for those release
+versions.*

package/README.md

@@ -245,9 +245,27 @@ Bug reports and PRs welcome at <https://github.com/kitchen-engineer42/kc-cli>.
 
 ## License
 
-MIT. Bundled meta-skills under `template/skills/` are proprietary —
-distributed via npm but not open-source. See `template/skills/LICENSE` for
-terms.
+KC v0.7.0+ is **dual-licensed** under [PolyForm Noncommercial 1.0.0](./LICENSE)
+plus a separate commercial license available on request.
+
+- **Personal users, students, hobbyists, public-research orgs,
+  charities, and government institutions** — use, modify, and self-host
+  KC for free under [LICENSE](./LICENSE) (PolyForm Noncommercial 1.0.0).
+- **Enterprises in production** (for-profit company workflows, hosting
+  KC as a paid service, distributing KC inside a commercial product) —
+  require a commercial license. See [LICENSE-COMMERCIAL.md](./LICENSE-COMMERCIAL.md)
+  for terms and how to contact us.
+- **Redistribution as a competing or independent product** — forbidden
+  under both license tracks. Internal forks for licensee use are fine
+  with the `Required Notice:` preserved; releasing KC under another
+  name as a new offering is not.
+
+KC v0.6.x and earlier remain under MIT for those release versions
+(licenses can't be retroactively changed); the v0.7.0 cutover applies
+to all subsequent commits and releases.
+
+Bundled meta-skills under `template/skills/` follow the same dual
+license as KC itself.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kc-beta",
-  "version": "0.6.1",
-  "description": "KC Agent — LLM document verification agent (pure Node.js CLI)",
+  "version": "0.7.0",
+  "description": "KC Agent — LLM document verification agent (pure Node.js CLI). Dual-licensed: PolyForm Noncommercial 1.0.0 for personal/noncommercial use; commercial license required for enterprise production. See LICENSE and LICENSE-COMMERCIAL.md.",
   "type": "module",
   "bin": {
     "kc-beta": "bin/kc-beta.js"
@@ -9,10 +9,17 @@
   "files": [
     "bin/",
     "src/",
+    "!src/cli/meme.source.js",
     "template/",
     "README.md",
-    "QUICKSTART.md"
+    "QUICKSTART.md",
+    "LICENSE",
+    "LICENSE-COMMERCIAL.md"
   ],
+  "scripts": {
+    "build:meme": "node scripts/build-meme.js",
+    "prepublishOnly": "node scripts/build-meme.js"
+  },
   "homepage": "https://github.com/kitchen-engineer42/kc-cli",
   "repository": {
     "type": "git",
@@ -28,8 +35,10 @@
     "ink": "^6.0.0",
     "ink-text-input": "^6.0.0",
     "ink-spinner": "^5.0.0",
+    "mammoth": "^1.6.0",
     "react": "^19.0.0",
-    "pdfjs-dist": "^4.0.0"
+    "pdfjs-dist": "^4.0.0",
+    "word-extractor": "^1.0.4"
   },
   "keywords": [
     "document-verification",
@@ -38,5 +47,5 @@
     "cli"
   ],
   "author": "kitchen-engineer42",
-  "license": "MIT"
+  "license": "SEE LICENSE IN LICENSE"
 }

package/src/agent/context-window.js

@@ -1,4 +1,5 @@
 import { estimateTokens, estimateMessagesTokens } from "./token-counter.js";
+import { findSafeSplitPoint } from "./message-utils.js";
 
 /**
  * Automatic context windowing for long conversations.
@@ -38,18 +39,14 @@ export class ContextWindow {
       return { messages, wasWindowed: false, removedCount: 0 };
     }
 
-    // Split into older and recent. The recent slice is fed directly to the
-    // LLM, so it must not begin with an orphan "tool" message — those carry a
-    // tool_call_id that references an assistant `tool_calls` entry, and if
-    // that assistant message ended up in the compressed older slice the
-    // provider rejects the request (OpenAI: "tool messages must follow an
-    // assistant with tool_calls"; Anthropic: unpaired tool_use/tool_result).
-    // Walk the split point forward past any leading tool rows so the recent
-    // window always starts on a turn boundary.
-    let splitPoint = Math.max(0, messages.length - this.recentWindowSize);
-    while (splitPoint < messages.length && messages[splitPoint]?.role === "tool") {
-      splitPoint++;
-    }
+    // Split into older and recent. v0.6.3.1: tool-pair atomicity is a
+    // bidirectional invariant — recent[0] must not be a `tool` (orphan,
+    // its assistant_with_tool_calls got summarized away) AND older[-1]
+    // must not be `assistant_with_tool_calls` (its tool results sit at
+    // the start of recent and the older summary corrupts that pairing).
+    // Use the shared `findSafeSplitPoint` helper from engine.js.
+    const desiredSplit = Math.max(0, messages.length - this.recentWindowSize);
+    const splitPoint = findSafeSplitPoint(messages, desiredSplit);
     const recentMessages = messages.slice(splitPoint);
     const olderMessages = messages.slice(0, splitPoint);
 

package/src/agent/context.js

@@ -149,12 +149,25 @@ export class ContextAssembler {
    * @param {string} [opts.pipelineState]
    * @param {string} [opts.workspaceState]
    * @param {string} [opts.skillIndex] - Brief index of available meta skills
+   * @param {string} [opts.projectMemory] - v0.7.0 B3: rules/PATTERNS.md
+   *   content. Capped at ~5 KB by the caller. Surfaced for phases the
+   *   work-decomposition skill operates in (skill_authoring + skill_testing).
    * @returns {string}
    */
-  build({ agentMd, pipelineState, workspaceState, skillIndex } = {}) {
+  build({ agentMd, pipelineState, workspaceState, skillIndex, projectMemory } = {}) {
     const parts = [AGENT_IDENTITY];
     if (agentMd) parts.push(agentMd);
     if (skillIndex) parts.push(skillIndex);
+    if (projectMemory) {
+      parts.push(
+        "## Project memory (rules/PATTERNS.md)\n\n" +
+        "Patterns + decisions you've accumulated this session. Treat as " +
+        "your prior decisions on this corpus — apply them; update the file " +
+        "when you discover something better. The work-decomposition skill " +
+        "covers what to write here vs. NOT to write.\n\n" +
+        "```markdown\n" + projectMemory.trim() + "\n```",
+      );
+    }
     if (pipelineState) parts.push(pipelineState);
     if (workspaceState) parts.push(workspaceState);
     return parts.join("\n\n");

package/src/agent/document-parser.js

@@ -0,0 +1,169 @@
+/**
+ * v0.7.0 G (#91): native document parser dispatcher.
+ *
+ * Centralizes the "given a file path, give me text" operation across
+ * formats KC handles. Strategy stack:
+ *
+ *   .pdf         → pdfjs-dist (already a hard dep)
+ *   .docx        → mammoth                (npm dep, dynamic-imported)
+ *   .doc         → word-extractor          (npm dep, dynamic-imported)
+ *   .txt / .md   → fs.readFileSync UTF-8 (with GBK fallback for CJK)
+ *   anything     → plaintext-utf8 best-effort, then LibreOffice fallback
+ *
+ * `mammoth` and `word-extractor` are dynamic-imported so the module
+ * degrades gracefully when they're not installed: missing dep → fall
+ * through to plaintext / LibreOffice. Lets KC ship without forcing
+ * users to run `npm install` post-upgrade if they don't touch
+ * DOCX/DOC content.
+ *
+ * The standalone PDF tool `tools/document-parse.js` (which has its
+ * own VLM/OCR escalation logic for image-PDFs) keeps its richer
+ * pipeline; this module is for the lower-friction "just give me
+ * text" path that document-chunk uses.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+/**
+ * @returns {Promise<{text: string, via: string, ok: boolean, error?: string}>}
+ */
+export async function extractText(filePath) {
+  const suffix = path.extname(filePath).toLowerCase();
+
+  if (suffix === ".pdf") {
+    const text = await _tryPdfjs(filePath);
+    if (text !== null) return { text, via: "pdfjs", ok: true };
+  }
+
+  if (suffix === ".docx") {
+    const text = await _tryMammoth(filePath);
+    if (text !== null) return { text, via: "mammoth", ok: true };
+  }
+
+  if (suffix === ".doc") {
+    const text = await _tryWordExtractor(filePath);
+    if (text !== null) return { text, via: "word-extractor", ok: true };
+  }
+
+  if (suffix === ".txt" || suffix === ".md" || suffix === ".csv" || suffix === ".json") {
+    const text = _tryPlaintext(filePath);
+    if (text !== null) return { text, via: "plaintext", ok: true };
+  }
+
+  // Generic fallbacks for anything we couldn't parse natively (or where
+  // the native lib isn't installed): plaintext first, then LibreOffice
+  // CLI as a last resort.
+  const plain = _tryPlaintext(filePath);
+  if (plain !== null) return { text: plain, via: "plaintext_fallback", ok: true };
+
+  const lo = _tryLibreOffice(filePath);
+  if (lo !== null) return { text: lo, via: "libreoffice_fallback", ok: true };
+
+  return {
+    text: "",
+    via: "none",
+    ok: false,
+    error: `no parser available for ${suffix || "(no extension)"}`,
+  };
+}
+
+// --- internals ---
+
+async function _tryPdfjs(filePath) {
+  try {
+    const pdfjsLib = await import("pdfjs-dist/legacy/build/pdf.mjs");
+    const data = new Uint8Array(fs.readFileSync(filePath));
+    const doc = await pdfjsLib.getDocument({ data, useSystemFonts: true }).promise;
+    const parts = [];
+    for (let i = 1; i <= doc.numPages; i++) {
+      const page = await doc.getPage(i);
+      const content = await page.getTextContent();
+      parts.push(content.items.map((it) => it.str || "").join(" "));
+    }
+    return parts.join("\n");
+  } catch {
+    return null;
+  }
+}
+
+async function _tryMammoth(filePath) {
+  try {
+    const mammoth = await import("mammoth");
+    const result = await mammoth.extractRawText({ path: filePath });
+    return result.value || "";
+  } catch {
+    return null; // mammoth not installed OR file unreadable
+  }
+}
+
+async function _tryWordExtractor(filePath) {
+  try {
+    const { default: WordExtractor } = await import("word-extractor");
+    const extractor = new WordExtractor();
+    const doc = await extractor.extract(filePath);
+    return doc.getBody() || "";
+  } catch {
+    return null;
+  }
+}
+
+function _tryPlaintext(filePath) {
+  try {
+    const buf = fs.readFileSync(filePath);
+    // Heuristic: if the buffer parses as UTF-8 cleanly (no replacement
+    // characters), use it. Otherwise try GBK for CJK corpora.
+    const utf8 = buf.toString("utf-8");
+    if (!utf8.includes("�")) return utf8;
+    // GBK fallback (only commonly relevant on Chinese corpora)
+    try {
+      // Node has TextDecoder("gbk") via ICU on most builds
+      const gbk = new TextDecoder("gbk", { fatal: false }).decode(buf);
+      if (gbk && !gbk.includes("�")) return gbk;
+    } catch { /* GBK not supported on this Node build */ }
+    // Last resort: return UTF-8 with replacement characters; caller
+    // can decide whether to use it.
+    return utf8;
+  } catch {
+    return null;
+  }
+}
+
+function _tryLibreOffice(filePath) {
+  // soffice/libreoffice CLI fallback. Best-effort; returns null on any
+  // failure so caller falls back to "no parser available."
+  const lo = _findLibreOffice();
+  if (!lo) return null;
+  try {
+    const outDir = path.join(path.dirname(filePath), ".kc-lo-out");
+    fs.mkdirSync(outDir, { recursive: true });
+    const r = spawnSync(
+      lo,
+      ["--headless", "--convert-to", "txt", "--outdir", outDir, filePath],
+      { timeout: 60_000 },
+    );
+    if (r.status !== 0) return null;
+    const stem = path.basename(filePath, path.extname(filePath));
+    const out = path.join(outDir, stem + ".txt");
+    if (!fs.existsSync(out)) return null;
+    const text = fs.readFileSync(out, "utf-8");
+    // Best-effort cleanup of the conversion output
+    try { fs.unlinkSync(out); } catch { /* ignore */ }
+    return text;
+  } catch {
+    return null;
+  }
+}
+
+function _findLibreOffice() {
+  // Use which/where heuristic — synchronous, fine at extract-time.
+  const candidates = ["soffice", "libreoffice"];
+  for (const cmd of candidates) {
+    try {
+      const r = spawnSync(cmd, ["--version"], { timeout: 5_000 });
+      if (r.status === 0) return cmd;
+    } catch { /* not on PATH */ }
+  }
+  return null;
+}