mindslice-forge 0.1.0__py3-none-any.whl

mindslice_forge-0.1.0.dist-info/METADATA

@@ -0,0 +1,275 @@
+Metadata-Version: 2.4
+Name: mindslice-forge
+Version: 0.1.0
+Summary: Turn documents into a MindSlice workspace by driving an agent harness (Python stdlib only).
+Author: pancerZH
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/pancerZH/MindSlice-forge
+Project-URL: Issues, https://github.com/pancerZH/MindSlice-forge/issues
+Project-URL: MindSlice, https://github.com/pancerZH/MindSlice
+Keywords: llm,agents,memory,markdown,mindslice
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mindslice-forge
+
+Turn documents into a [MindSlice](https://github.com/pancerZH/MindSlice) workspace.
+
+MindSlice is the memory engine. The forge is the tool that fills it: it takes one long document, a
+folder of many files, or a mixture, drives the agent harness you choose through the conversion,
+and checks every result with the `mindslice` command. Sources of any size work,
+because they are read in chunks and each chunk is handled by a fresh agent session that continues
+the work of the ones before it.
+
+The forge itself is small on purpose. It keeps the inventory, the state, the checkpoints and the
+checks; everything that needs understanding of the text is done by the agent, following the
+templates in [`mindslice_forge/prompts/`](https://github.com/pancerZH/MindSlice-forge/tree/main/mindslice_forge/prompts).
+
+Python 3.12+, standard library only. Needs `mindslice` 0.1.0 or newer, `git`, and an agent harness
+that can run a session unattended from the command line.
+
+## When to use Forge
+
+Use Forge when you want an agent to distill source documents into topic cards. MindSlice itself
+handles the other starting points without Forge:
+
+- `mindslice init <workspace>` creates empty memory for learning through conversation.
+- `mindslice -w <workspace> ...` opens an existing workspace directly.
+- `mindslice -w <workspace> mount <directory>` mounts a `.slice` or a plain Markdown notes folder
+  read-only, without LLM conversion.
+
+MindSlice's [setup skill](https://github.com/pancerZH/MindSlice/blob/main/skills/mindslice-setup/SKILL.md)
+guides onboarding; its [builder skill](https://github.com/pancerZH/MindSlice/blob/main/skills/slice-builder/SKILL.md)
+uses Forge for conversion and connects the result. Forge is optional for MindSlice users; the
+engine does not call an LLM or require Forge as a runtime dependency.
+
+## Install
+
+```bash
+pipx install mindslice-forge   # or: uv tool install mindslice-forge
+```
+
+Install the MindSlice engine the same way (`pipx install mindslice`): Forge and the agent sessions
+it starts call the `mindslice` command by name, so both must be on `PATH`. Make sure the harness
+you will use is authenticated and its model is available.
+
+*(For local development from source: `git clone https://github.com/pancerZH/MindSlice-forge.git && cd MindSlice-forge && pipx install -e .`.)*
+
+## Use
+
+```bash
+HARNESS='...'   # the command that runs one agent session: see "The harness command" below
+mindslice-forge novel.txt \
+    --harness-cmd "$HARNESS" \
+    --dict wiki-summary.txt \
+    --prompt "Extract the world and its background for solo role-play. Record how a thing changes over time as several cards that extend one another, not as one crowded card." \
+    --sample 2 \
+    -o ./novel.workspace
+```
+
+| Argument | Meaning |
+| --- | --- |
+| `SOURCE...` | Documents or folders to convert. Text files in UTF-8, GB18030 or UTF-16; other files are listed and left out. |
+| `--dict PATH` | A reference frame: an outline, glossary or encyclopedia page about the sources. It shapes names and structure and is never a source of facts. Repeatable. |
+| `--prompt TEXT_OR_FILE` | What to extract and how. |
+| `-o, --output DIR` | The workspace to create. Default: `./<first source name>.workspace`. |
+| `--sample N` | Process only the first N chunks, to try a prompt before a long run. |
+| `--chunk-size CHARS` | Target size of a chunk. Default 100000 characters. |
+| `--harness-cmd COMMAND` | The command line that runs one agent session; see [The harness command](#the-harness-command). Needed for everything except `--dry-run`. |
+| `--from STAGE` | Redo the build from `plan`, `split`, `extract` or `finalize`. |
+| `--dry-run` | Show the inventory, the directories a session must reach and what would run. Calls no agent and writes nothing. |
+
+```bash
+mindslice-forge ./project-docs ./adr --harness-cmd "$HARNESS" \
+    --prompt "Rules, architecture and operating procedures for new engineers."
+```
+
+**Running the same command again continues an unfinished build.** A typical session:
+
+```bash
+mindslice-forge novel.txt --harness-cmd "$HARNESS" --prompt prompt.md --sample 2   # try two chunks
+git -C novel.workspace log -p                             # see what each chunk produced
+# edit prompt.md
+mindslice-forge novel.txt --harness-cmd "$HARNESS" --prompt prompt.md --sample 2 --from extract   # extract again
+mindslice-forge novel.txt --harness-cmd "$HARNESS" --prompt prompt.md              # satisfied: run the rest
+```
+
+If the sources, the dict, the prompt or the chunk size change after a build has started, the forge
+refuses to continue silently: say which stage to redo with `--from`, or choose another output.
+
+## The harness command
+
+Forge knows no agent product. You give it the command line that runs **one agent session** of
+the harness you use, with its model and options, and Forge runs that command once per step: from
+the forge directory, with no terminal attached, after filling in the placeholders `{message}`
+(one line telling the agent to read the prompt file and do what it says), `{prompt_file}` and
+`{workdir}`. Do not quote the placeholders. The command must:
+
+- contain `{message}` or `{prompt_file}`, so that the agent receives its task;
+- name files and directories by absolute paths, as it does not run from your directory;
+- end when the task is done, with exit status 0 on success;
+- never wait for an answer: no questions, and no permission prompts for reading and writing
+  files or running shell commands;
+- let the agent write in the workspace and the forge directory and read the sources and every
+  `--dict` (`--dry-run` lists these directories);
+- give the agent's shell a `PATH` with the `mindslice` command.
+
+`mindslice-forge --help` prints the same list. Take the options from your harness's own help:
+look for its non-interactive mode (often called print, exec or headless), the option that
+approves tool use without asking, the option for the model, and, if it limits file access, the
+option that grants directories. As an illustration only, this is such a command for Antigravity's
+`agy`; other harnesses, and other versions of this one, have their own options:
+
+```bash
+HARNESS='agy --print={message} --dangerously-skip-permissions --disable-slash-commands --output-format stream-json \
+  --model <model> --add-dir /abs/novel.workspace --add-dir /abs/sources'
+```
+
+**A new command is checked before it is used.** Before the first step with a command, one short
+session has to run `mindslice --version`, read a source file and write a file in the workspace.
+If it cannot, the build stops there, within seconds or minutes, and says which requirement
+failed and how the session's log ends. The command that passed is recorded in the forge
+directory; changing the command, for example to another model, checks it again.
+
+## One document or many
+
+Files and chunks are units of reading, nothing more. They decide neither the slices nor the cards.
+
+- **A folder** is read recursively. Hidden files and folders are ignored; files that are not text
+  (images, PDF, Word) are listed in the inventory and left out, so convert those to text first.
+- **Small files** are kept whole and share a chunk; **a large file** is cut at its own chapters or
+  sections. The agent decides the grouping and the reading order when it plans: related files
+  together, what the rest builds on first. It can leave out a whole file, such as generated
+  output or a copy, and must give the reason.
+- **Everything is accounted for.** Every line of every text file ends up in exactly one chunk or
+  in a skipped range with a reason; the forge checks this before any card is written.
+- **Cards follow topics.** Several files can feed one card and one file can feed many. Where files
+  disagree, the later one does not win by being read later: the cards record what each statement
+  applies to, and unresolved disagreements are listed in the report.
+- If everything fits in one chunk, no splitting happens and one session reads it all.
+
+## How it works
+
+| Stage | Who | What happens |
+| --- | --- | --- |
+| profile | forge | Lists the sources with their encoding, line count and size. |
+| plan | agent, one session | Studies the structure of the documents and how the files relate, reads the dict, writes the build plan (slices, folders, card paths, reading order, how change over time is recorded), creates the slices, and writes a splitter program if the sources do not fit in one chunk. |
+| split | forge | Runs the splitter and checks that every source line is in exactly one chunk or in a declared skipped range, and that no chunk is too large or has lost text. Problems go back to the agent. |
+| extract | agent, one session per chunk, in order | Is told which files and lines the chunk holds, reads it in full, searches the workspace for what already exists, writes or extends cards, and leaves a ledger and a note for the next session. |
+| finalize | agent, one session | Writes each slice's overview, clears remaining problems, tries retrieval questions, and writes the report. |
+
+After every agent session the forge runs `mindslice validate`. Errors, and fixable warnings on the
+cards that session touched, go to a repair session (at most `--max-repairs`). Errors that survive
+stop the build; warnings do not, and are listed in the report. A session that fails or times out
+is rolled back and retried.
+
+**Search before creating cards is a required check.** The extract and finalize prompts provide a
+`python /path/to/mindslice_forge/lookup.py WORKSPACE "name"` command. It searches the workspace
+through `mindslice search --json` and records successful searches in the forge directory's
+`lookups.jsonl`. Search each name separately. Every new card must have a title or alias covered
+by a lookup from that step or its repairs: the whole query occurs in the title/alias or vice
+versa, ignoring case and respecting Latin word boundaries. A base name can cover period cards.
+Older steps and failed attempts do not count; edits to existing cards and slice overviews are
+exempt. Missing lookups are errors that stop the build if repairs cannot resolve them.
+
+Repairs must search the missing names, read matches, and merge duplicate cards into the one that
+already existed, preserving facts and updating links. This check verifies search coverage at the
+end of the step; deciding whether two cards describe the same thing remains the agent's job.
+
+## Output
+
+```text
+novel.workspace/            a MindSlice workspace, ready for `mindslice -w novel.workspace ...`
+├── mounts.toml, overlay/, staging/
+├── slices/<name>.slice/    the cards, mounted
+└── .git/                   one commit per finished chunk: the checkpoints (slices and mounts only)
+novel.workspace.forge/      build state and evidence; keep it for resume and review
+├── state.json, harness.json  progress, and the harness command that passed its check
+├── profile.md, plan.md, split.py, report.md
+├── chunks/                 the chunk files and manifest.json
+├── ledger/, handoff/       per chunk: what was recorded, and the note for the next session
+├── lookups.jsonl           successful name searches
+└── prompts/, logs/         every prompt as it was sent, and each session's output
+```
+
+The forge directory lives next to the workspace so that workspace backups do not carry a copy of
+the sources.
+
+## Connect the result to MindSlice
+
+**For a new workspace**, pass the intended workspace path to Forge with `-o`. Forge initializes
+it and mounts the generated slices; do not run `mindslice init` there first. After checking the
+report, validation and representative facts, use `mindslice -w <output> ...` or connect your
+agent's MCP server to that workspace.
+
+A connected workspace can still be built further: run the same command to continue a sample, or
+use `--from` to redo a stage. What the agent has learned in the meantime (`overlay/`, `staging/`
+and the engine's `.history/`) is kept out of the checkpoints, so no rerun, retry or rollback
+touches it. If the slices or the mount table were changed outside the forge, by `mindslice bake`,
+`mount` or `unmount` or by hand, the forge stops and lists the changes instead of discarding
+them; build into another output and mount its slices. Do not bake or change mounts while a build
+is running.
+
+**For an existing workspace**, build into a separate new directory. Forge cannot take over a
+nonempty workspace that it did not create. Inspect the resulting `slices/*.slice` aliases and
+dependencies, then mount the selected individual slices. For example, if the build produced
+`handbook.slice` and its alias is available in your destination:
+
+```bash
+mindslice -w ~/mindslice mount /path/to/build.workspace/slices/handbook.slice \
+  --precedence 50 --role curated
+mindslice -w ~/mindslice validate
+```
+
+Mount each required slice separately, preserving aliases used by cross-slice links. Resolve
+collisions before mounting; do not silently replace an existing mount. The workspace root,
+`slices/` parent and `.forge/` build directory are not slice mount targets.
+
+Keep mounted paths stable. If you plan further Forge rebuilds, first copy the selected slices to
+new durable library directories or the destination's `slices/` directory and mount those copies.
+Otherwise a rebuild or rollback can change the files the live workspace reads. Keep the sibling
+`.forge/` directory for resume and evidence; completed slice artifacts do not depend on it at runtime.
+
+Validation checks structure, and recorded lookups check search coverage. Neither establishes that
+the model preserved every fact. Treat input coverage, retrieval and source fidelity as separate
+checks; a sampled build remains partial after it is connected to an agent.
+
+## Safety
+
+- Select allowed sources before invoking Forge, including `--dry-run`: recursive scanning does
+  not honor project ignore files or forbidden-directory markers. Pass selected files or prepare
+  an allowed snapshot with exclusions applied before traversal. Keep output, reference files and
+  conversion prompts outside the source directories.
+- The harness command you give runs agents with tool permissions approved automatically, and the
+  splitter is a program the agent wrote. Convert sources you trust, or run the forge in a sandbox.
+- Forge writes its output workspace and sibling `.forge/` directory. It refuses to take over an
+  existing nonempty output it did not create. Rollbacks happen inside its output directory and
+  cover the slices and the mount table only, never `overlay/`, `staging/` or `.history/`.
+
+## Tests
+
+```bash
+python -m unittest discover -s tests -t . -v
+```
+
+The unit tests need nothing. The functional tests run whole builds with the real `mindslice` and
+`git` commands and a fake agent ([`tests/fake_harness.py`](https://github.com/pancerZH/MindSlice-forge/blob/main/tests/fake_harness.py)); no model is
+called.
+
+### Checking a first real run
+
+After a `--sample 2` run against a real harness, look at:
+
+- the `[split]` line: the chunk count and the first and last titles should match the document;
+  `novel.workspace.forge/chunks/manifest.json` lists what was skipped and why;
+- `git -C novel.workspace log --stat`: one commit per chunk, with the cards it touched;
+- `mindslice -w novel.workspace validate`, and a few searches and reads of things you know are in
+  the first chunks, including one that changes over time;
+- `novel.workspace.forge/report.md`.

mindslice_forge-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+mindslice_forge/__init__.py,sha256=4-RV2O6Jiw6Oo0TMVDvmDkHeOr4RBDJQPedyGx1qYSk,504
+mindslice_forge/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+mindslice_forge/checkpoint.py,sha256=j332VW0oXnih0vjpN4I3nP3sPASy4JWX99DrSQwAIIw,4745
+mindslice_forge/cli.py,sha256=qNePXGU2kPSrvCrjxhc_W87RYQ8w5tWTbV0yqQae7UI,4438
+mindslice_forge/engine.py,sha256=D_S8rfjLqtZxwoNUl5pvDW03F_wGZd6gurZyerFVUok,3931
+mindslice_forge/harness.py,sha256=QdU387bR1FiWC35Te1Rw6xjAXIG4-2R8Jq8JcqhrPTc,3836
+mindslice_forge/lookup.py,sha256=H2FQnPc8lxXFGwloBeuuGEQzD4G0fJAvYaGGzvZ7rAI,3393
+mindslice_forge/pipeline.py,sha256=Mhpvl7xhuUDG8trmqyFnmLX6uB_MAC2Ws7ws2rSOOcw,20556
+mindslice_forge/profile.py,sha256=FAuNmQQS99lBc8Xrj7uDvjfjHSi3-J7c4nqdbcWw75U,2969
+mindslice_forge/split.py,sha256=iDorZigZ_Cxwu1bfhw0F07yIakdPv3jSfRCmq9FcTEo,6583
+mindslice_forge/state.py,sha256=YNc1e7sNUWTkQckWez-HkA78WPxYyhDXel-p_uwib1M,1481
+mindslice_forge/prompts/card-format.md,sha256=FPRSCCoTs5OBwO696x7GWzw-sMKc7zD1lL53AQ3O8BY,5051
+mindslice_forge/prompts/extract.md,sha256=xIGOLVWAycZmoLBqSirhuW0aBPCA2ScY4MrUbKhT-T4,5874
+mindslice_forge/prompts/finalize.md,sha256=JmMr4UYOGI3icN64hJFQZf5m39qayg_kAXcb1FxyVH8,3799
+mindslice_forge/prompts/plan.md,sha256=Za3PXodn5QEK5SLN0129OnQVSZX8nJPMeZXOSUWNPmQ,7977
+mindslice_forge/prompts/probe.md,sha256=-GL3RR1poyiHjOq4XqUzumvAXzg0tUy28LmNFTSSnsM,762
+mindslice_forge/prompts/repair.md,sha256=vqX6eXDXkDX2AZwK2mkZ2fJEOc-Mr9Z80wibCZDhOcA,1437
+mindslice_forge-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+mindslice_forge-0.1.0.dist-info/METADATA,sha256=xYMFqIYwbvNpoWS8O62oYs6XKDOpMeR3Mw1Zg69qbAs,16249
+mindslice_forge-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+mindslice_forge-0.1.0.dist-info/entry_points.txt,sha256=L1-jJGQCOhTn1BDxDqGWQ4W_evQ-f_O_cYKQ8mChxeA,61
+mindslice_forge-0.1.0.dist-info/top_level.txt,sha256=UG2QCvNTpBUju2BqXotNFmhSoPmCAbB1Wi9Sc57X48g,16
+mindslice_forge-0.1.0.dist-info/RECORD,,

mindslice_forge-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mindslice_forge-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mindslice-forge = mindslice_forge.cli:main

mindslice_forge-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mindslice_forge-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mindslice_forge