Metadata-Version: 2.4
Name: lastlight
Version: 0.1.0
Summary: Low-power, offline retrieval for disaster and infrastructure-failure guidance.
Author: Eduardo J. Barrios
License: Mozilla Public License Version 2.0
        ==================================
        
        1. Definitions
        --------------
        
        1.1. "Contributor" means each individual or legal entity that creates,
        contributes to the creation of, or owns Covered Software.
        
        1.2. "Contributor Version" means the combination of the Contributions of
        others, if any, used by a Contributor and that particular Contributor's
        Contribution.
        
        1.3. "Contribution" means Covered Software of a particular Contributor.
        
        1.4. "Covered Software" means Source Code Form to which the initial Contributor
        has attached the notice in Exhibit A, the Executable Form of such Source Code
        Form, and Modifications of such Source Code Form, in each case including
        portions thereof.
        
        1.5. "Incompatible With Secondary Licenses" means that the initial Contributor
        has attached the notice described in Exhibit B to the Covered Software; or that
        the Covered Software was made available under the terms of version 1.1 or
        earlier of the License, but not also under the terms of a Secondary License.
        
        1.6. "Executable Form" means any form of the work other than Source Code Form.
        
        1.7. "Larger Work" means a work that combines Covered Software with other
        material, in a separate file or files, that is not Covered Software.
        
        1.8. "License" means this document.
        
        1.9. "Licensable" means having the right to grant, to the maximum extent
        possible, whether at the time of the initial grant or subsequently, any and all
        of the rights conveyed by this License.
        
        1.10. "Modifications" means any of the following:
        
        (a) any file in Source Code Form that results from an addition to, deletion
        from, or modification of the contents of Covered Software; or
        
        (b) any new file in Source Code Form that contains any Covered Software.
        
        1.11. "Patent Claims" of a Contributor means any patent claim(s), including
        without limitation, method, process, and apparatus claims, in any patent
        Licensable by such Contributor that would be infringed, but for the grant of
        the License, by the making, using, selling, offering for sale, having made,
        import, or transfer of either its Contributions or its Contributor Version.
        
        1.12. "Secondary License" means either the GNU General Public License, Version
        2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General
        Public License, Version 3.0, or any later versions of those licenses.
        
        1.13. "Source Code Form" means the form of the work preferred for making
        modifications.
        
        1.14. "You" means an individual or a legal entity exercising rights under this
        License.
        
        2. License Grants and Conditions
        --------------------------------
        
        2.1. Grants
        
        Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive
        license:
        
        (a) under intellectual property rights other than patent or trademark
        Licensable by such Contributor to use, reproduce, make available, modify,
        display, perform, distribute, and otherwise exploit its Contributions, either
        on an unmodified basis, with Modifications, or as part of a Larger Work; and
        
        (b) under Patent Claims of such Contributor to make, use, sell, offer for sale,
        have made, import, and otherwise transfer either its Contributions or its
        Contributor Version.
        
        2.2. Effective Date
        
        The licenses granted in Section 2.1 with respect to any Contribution become
        effective for each Contribution on the date the Contributor first distributes
        such Contribution.
        
        2.3. Limitations on Grant Scope
        
        The licenses granted in this Section 2 are the only rights granted under this
        License. No additional rights or licenses will be implied from the distribution
        or licensing of Covered Software under this License. Notwithstanding Section
        2.1(b) above, no patent license is granted by a Contributor:
        
        (a) for any code that a Contributor has removed from Covered Software; or
        
        (b) for infringements caused by: (i) Your and any other third party's
        modifications of Covered Software, or (ii) the combination of its Contributions
        with other software except as part of its Contributor Version; or
        
        (c) under Patent Claims infringed by Covered Software in the absence of its
        Contributions.
        
        This License does not grant any rights in the trademarks, service marks, or
        logos of any Contributor except as necessary to comply with Section 3.4.
        
        2.4. Subsequent Licenses
        
        No Contributor makes additional grants as a result of Your choice to distribute
        the Covered Software under a subsequent version of this License.
        
        2.5. Representation
        
        Each Contributor represents that the Contributor believes its Contributions are
        its original creation(s) or it has sufficient rights to grant the rights to its
        Contributions conveyed by this License.
        
        2.6. Fair Use
        
        This License is not intended to limit any rights You have under applicable
        copyright doctrines of fair use, fair dealing, or other equivalents.
        
        2.7. Conditions
        
        Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
        Section 2.1.
        
        3. Responsibilities
        -------------------
        
        3.1. Distribution of Source Form
        
        All distribution of Covered Software in Source Code Form, including any
        Modifications that You create or to which You contribute, must be under the
        terms of this License. You must inform recipients that the Source Code Form of
        the Covered Software is governed by the terms of this License, and how they can
        obtain a copy of this License. You may not attempt to alter or restrict the
        recipients' rights in the Source Code Form.
        
        3.2. Distribution of Executable Form
        
        If You distribute Covered Software in Executable Form then:
        
        (a) such Covered Software must also be made available in Source Code Form, as
        described in Section 3.1, and You must inform recipients how they can obtain a
        copy of such Source Code Form by reasonable means in a timely manner, at a
        charge no more than the cost of distribution to the recipient; and
        
        (b) You may distribute such Executable Form under the terms of this License, or
        sub-license it under different terms, provided that the license for the
        Executable Form does not attempt to limit or alter the recipients' rights in the
        Source Code Form under this License.
        
        3.3. Distribution of a Larger Work
        
        You may create and distribute a Larger Work under terms of Your choice,
        provided that You also comply with the requirements of this License for the
        Covered Software. If the Larger Work is a combination of Covered Software with
        a work governed by one or more Secondary Licenses, and the Covered Software is
        not Incompatible With Secondary Licenses, this License permits You to
        additionally distribute such Covered Software under the terms of such Secondary
        License(s), so that the recipient of the Larger Work may, at their option,
        further distribute the Covered Software under the terms of either this License
        or such Secondary License(s).
        
        3.4. Notices
        
        You may not remove or alter the substance of any license notices contained
        within the Source Code Form of the Covered Software, except that You may alter
        any license notices to the extent required to remedy known factual inaccuracies.
        
        3.5. Application of Additional Terms
        
        You may choose to offer, and to charge a fee for, warranty, support, indemnity
        or liability obligations to one or more recipients of Covered Software.
        However, You may do so only on Your own behalf, and not on behalf of any
        Contributor. You must make it absolutely clear that any such warranty, support,
        indemnity, or liability obligation is offered by You alone, and You hereby
        agree to indemnify every Contributor for any liability incurred by such
        Contributor as a result of warranty, support, indemnity or liability terms You
        offer. You may include additional disclaimers of warranty and limitations of
        liability specific to any jurisdiction.
        
        4. Inability to Comply Due to Statute or Regulation
        ---------------------------------------------------
        
        If it is impossible for You to comply with any of the terms of this License
        with respect to some or all of the Covered Software due to statute, judicial
        order, or regulation then You must comply with the terms of this License to the
        maximum extent possible.
        
        5. Termination
        --------------
        
        5.1. The rights granted under this License will terminate automatically if You
        fail to comply with any of its terms. However, if You become compliant, then
        the rights granted under this License from a particular Contributor are
        reinstated (a) provisionally, unless and until such Contributor explicitly and
        finally terminates Your grants, and (b) on an ongoing basis, if such
        Contributor fails to notify You of the non-compliance by some reasonable means
        prior to 60 days after You have come back into compliance. Moreover, Your
        grants from a particular Contributor are reinstated on an ongoing basis if such
        Contributor notifies You of the non-compliance by some reasonable means, this
        is the first time You have received notice of non-compliance with this License
        from such Contributor, and You become compliant prior to 30 days after Your
        receipt of the notice.
        
        5.2. If You initiate litigation against any entity by asserting a patent
        infringement claim alleging that a Contributor Version directly or indirectly
        infringes any patent, then the rights granted to You by any and all
        Contributors for the Covered Software under Section 2.1 of this License shall
        terminate.
        
        5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
        license agreements (excluding distributors and resellers) which have been
        validly granted by You or Your distributors under this License prior to
        termination shall survive termination.
        
        6. Disclaimer of Warranty
        -------------------------
        
        Covered Software is provided under this License on an "as is" basis, without
        warranty of any kind, either expressed, implied, or statutory, including,
        without limitation, warranties that the Covered Software is free of defects,
        merchantable, fit for a particular purpose or non-infringing. The entire risk
        as to the quality and performance of the Covered Software is with You. Should
        any Covered Software prove defective in any respect, You assume the cost of any
        necessary servicing, repair, or correction. This disclaimer of warranty
        constitutes an essential part of this License. No use of any Covered Software
        is authorized under this License except under this disclaimer.
        
        7. Limitation of Liability
        --------------------------
        
        Under no circumstances and under no legal theory, whether tort (including
        negligence), contract, or otherwise, shall any Contributor, or anyone who
        distributes Covered Software as permitted above, be liable to You for any
        direct, indirect, special, incidental, or consequential damages of any character
        including, without limitation, damages for lost profits, loss of goodwill, work
        stoppage, computer failure or malfunction, or any and all other commercial
        damages or losses, even if such party shall have been informed of the
        possibility of such damages. This limitation of liability shall not apply to
        liability for death or personal injury resulting from such party's negligence
        to the extent applicable law prohibits such limitation. Some jurisdictions do
        not allow the exclusion or limitation of incidental or consequential damages,
        so this exclusion and limitation may not apply to You.
        
        8. Litigation
        -------------
        
        Any litigation relating to this License may be brought only in the courts of a
        jurisdiction where the defendant maintains its principal place of business and
        such litigation shall be governed by laws of that jurisdiction, without
        reference to its conflict-of-law provisions. Nothing in this Section shall
        prevent a party's ability to bring cross-claims or counter-claims.
        
        9. Miscellaneous
        ----------------
        
        This License represents the complete agreement concerning the subject matter
        hereof. If any provision of this License is held to be unenforceable, such
        provision shall be reformed only to the extent necessary to make it
        enforceable. Any law or regulation which provides that the language of a
        contract shall be construed against the drafter shall not be used to construe
        this License against a Contributor.
        
        10. Versions of the License
        ---------------------------
        
        10.1. New Versions
        
        Mozilla Foundation is the license steward. Except as provided in Section 10.3,
        no one other than the license steward has the right to modify or publish new
        versions of this License. Each version will be given a distinguishing version
        number.
        
        10.2. Effect of New Versions
        
        You may distribute the Covered Software under the terms of the version of the
        License under which You originally received the Covered Software, or under the
        terms of any subsequent version published by the license steward.
        
        10.3. Modified Versions
        
        If you create software not governed by this License, and you want to create a
        new license for such software, you may create and use a modified version of
        this License if you rename the license and remove any references to the name of
        the license steward, except to note that such modified license differs from
        this License.
        
        10.4. Distributing Source Code Form that is Incompatible With Secondary
        Licenses
        
        If You choose to distribute Source Code Form that is Incompatible With
        Secondary Licenses under the terms of this version of the License, the notice
        described in Exhibit B of this License must be attached.
        
        Exhibit A - Source Code Form License Notice
        -------------------------------------------
        
        This Source Code Form is subject to the terms of the Mozilla Public License,
        v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
        one at https://mozilla.org/MPL/2.0/.
        
        Exhibit B - "Incompatible With Secondary Licenses" Notice
        --------------------------------------------------------
        
        This Source Code Form is "Incompatible With Secondary Licenses", as defined by
        the Mozilla Public License, v. 2.0.
        
        
Project-URL: Homepage, https://github.com/edujbarrios/lastlight
Project-URL: Documentation, https://github.com/edujbarrios/lastlight/blob/main/docs/python_api.md
Project-URL: Repository, https://github.com/edujbarrios/lastlight
Project-URL: Issues, https://github.com/edujbarrios/lastlight/issues
Keywords: offline,retrieval,rag,emergency-preparedness,low-power
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Information Analysis
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
License-File: NOTICE
Dynamic: license-file

# LastLight

**Low-power, offline retrieval for disaster and infrastructure-failure guidance.**

Most modern AI research moves in one direction: larger models, larger context windows, more accelerators, more memory, and increasingly capable cloud infrastructure. That direction is useful, but it leaves a different question relatively unexplored: **what happens when the infrastructure itself is the problem?**

LastLight explores the reverse case. It asks how much useful machine-assisted reasoning can remain available when connectivity is unreliable or absent, power is scarce, hardware is modest, and a remote model cannot be assumed to exist.

The goal is not to reproduce a general-purpose cloud LLM on a tiny device. LastLight is designed for a narrower and more auditable job: **retrieve practical knowledge locally, show where it came from, operate within strict resource constraints, and refuse when the available evidence is not strong enough to support an answer.**

That makes it useful for scenarios such as prolonged outages, damaged communications infrastructure, remote field work, low-power devices, emergency preparation, or any environment where access to external services cannot be guaranteed.

LastLight works entirely from local knowledge packs. A device can carry one or several independently versioned packs—for example water, first aid, blackout procedures, communications, or navigation—and search them together without requiring a network connection.

No cloud API. No embeddings. No vector database. No telemetry. No package install required.

> Inspired by the resource-scarcity premise of *This War of Mine*. LastLight is an independent project and is not affiliated with the game or its creators.

## What LastLight provides

- mount **one or multiple** directory/ZIP knowledge packs at once
- deterministic lexical, BM25 and resource-adaptive retrieval
- sourced passages with pack and document traceability
- confidence-aware refusal instead of fabricating unsupported answers
- ES/EN language routing without silently translating source material
- pack metadata, validation, SHA-256 integrity, provenance and freshness checks
- a stdlib-only CLI suitable for constrained and disconnected systems

## Use LastLight as a Python library

LastLight is library-first: the CLI is a first-party client of the same public Python API that can be used by `lastlight-ui`, `lastlight-bench`, or other integrations.

Install it from a checkout:

```bash
python -m pip install .
```

Then query a local pack without parsing CLI output:

```python
from lastlight import LastLight

engine = LastLight(
    knowledge="examplepack/lastlight-example-en.zip",
    strategy="adaptive",
    mode="balanced",
)

result = engine.query(
    "The water supply is down and I have no bottled water. "
    "I found water that looks clear. What should I do before drinking it?"
)

if result.accepted:
    print(result.confidence)
    print(result.passage)
    print(result.sources[0].path)
```

`QueryResult`, `SourceResult`, and `RetrievalMetadata` are stable public contracts intended for companion repositories. See [Python API](docs/python_api.md) for multi-pack and adaptive examples.

## Try it in 30 seconds

The repository includes one deliberately small English demo archive at [`examplepack/lastlight-example-en.zip`](examplepack/lastlight-example-en.zip). It exists only so a new visitor can understand the system without downloading anything else.

```bash
git clone https://github.com/edujbarrios/lastlight.git
cd lastlight

python src/main.py \
  --knowledge examplepack/lastlight-example-en.zip \
  --validate-pack
```

```text
Pack validation: PASS
```

Ask a natural-language question and inspect the ranked source:

```bash
python src/main.py \
  --knowledge examplepack/lastlight-example-en.zip \
  --format sources \
  "The water supply is down and I have no bottled water. I found water that looks clear. What should I do before drinking it?"
```

Current default lexical result:

```text
Sources for: The water supply is down and I have no bottled water. I found water that looks clear. What should I do before drinking it?
1. [HIGH] Safe water during an emergency | lastlight-example-en.zip:en/water/purification.md | score=2.539 | tags=water, purification, emergency
```

The same question in normal text mode retrieves this answer:

```text
LastLight is experimental and retrieval-only. It shows sourced passages; it does not replace professional emergency guidance.

[HIGH CONFIDENCE]

Title: Safe water during an emergency
Source: lastlight-example-en.zip:en/water/purification.md
Language: en
Tags: water, purification, emergency

Passage:
If safe bottled water is not available, bring clear water to a rolling boil for 1 minute. At elevations above 6,500 feet (about 2,000 meters), boil water for 3 minutes. Let it cool and store it in clean, sanitized containers with tight covers.

Experimental offline research tool. Verify critical decisions with trusted human expertise whenever possible.

Follow-up checks:
- Does the water smell like fuel, chemicals, sewage, or solvents?
- Can you boil it, or do you only have filters, cloth, or disinfectant?
```

And when the pack does not contain enough evidence for the question, LastLight refuses instead of inventing an answer:

```bash
python src/main.py \
  --knowledge examplepack/lastlight-example-en.zip \
  "How do I repair a diesel engine that will not start?"
```

```text
I do not have enough confidence to answer this question from the current knowledge base.
```

## Compare retrieval strategies

LastLight exposes two fixed retrieval strategies and one adaptive policy. Adaptive retrieval is **strategy selection**, not a hidden model or a simultaneous blend of lexical and BM25 scores: it deterministically chooses the retrieval path for the current query and resource policy.

Using the same natural-language water query, fixed lexical retrieval returns the source above with a lexical score of `2.539`:

```bash
python src/main.py \
  --knowledge examplepack/lastlight-example-en.zip \
  --strategy lexical \
  --format sources \
  "The water supply is down and I have no bottled water. I found water that looks clear. What should I do before drinking it?"
```

Fixed BM25 ranks the same document first, using its own scoring scale:

```bash
python src/main.py \
  --knowledge examplepack/lastlight-example-en.zip \
  --strategy bm25 \
  --format sources \
  "The water supply is down and I have no bottled water. I found water that looks clear. What should I do before drinking it?"
```

```text
1. [HIGH] Safe water during an emergency | lastlight-example-en.zip:en/water/purification.md | score=7.159 | tags=water, purification, emergency
```

The numeric scores are **not comparable across lexical and BM25**; only ranking and confidence within each strategy are meaningful.

Adaptive mode makes the choice explicit. For this water query, the planner classifies the query as `high` risk:

| Mode | Selected strategy | Effective top-k | Why |
| --- | --- | ---: | --- |
| `survival` | lexical | 2 | caps retrieval cost |
| `balanced` | lexical | 3 | keeps high-risk queries on the safety-first path |
| `accuracy` | BM25 | 3 | uses BM25 when unconstrained and the query is not critical |

Inspect the decision directly:

```bash
python src/main.py \
  --knowledge examplepack/lastlight-example-en.zip \
  --strategy adaptive \
  --mode balanced \
  --plan \
  "The water supply is down and I have no bottled water. I found water that looks clear. What should I do before drinking it?"
```

Stable fields from the plan are:

```json
{
  "effective_top_k": 3,
  "mode": "balanced",
  "reason": "high-risk query in a safety-first mode",
  "risk": "high",
  "strategy": "lexical"
}
```

For a normal-risk query, balanced mode can switch to BM25:

```bash
python src/main.py \
  --knowledge examplepack/lastlight-example-en.zip \
  --strategy adaptive \
  --mode balanced \
  --plan \
  "The power has been out for several hours. How long will food stay safe in my refrigerator if I keep the door closed?"
```

```json
{
  "mode": "balanced",
  "reason": "balanced mode with sufficient detected resources",
  "risk": "normal",
  "strategy": "bm25"
}
```

Tight explicit budgets override the normal policy and force the lower-cost lexical path:

```bash
python src/main.py \
  --knowledge examplepack/lastlight-example-en.zip \
  --strategy adaptive \
  --mode balanced \
  --energy-budget-mwh 0.4 \
  --plan \
  "The power has been out for several hours. How long will food stay safe in my refrigerator if I keep the door closed?"
```

See [Adaptive Retrieval](docs/adaptive_retrieval.md) for the complete decision order and resource-policy thresholds.

The example pack is **onboarding data, not the distribution model**. Maintained knowledge packs, the UI, pack-authoring tools and the future catalog are intended to evolve in separate companion repositories. See [Ecosystem](ECOSYSTEM.md).

## Use your own knowledge packs

LastLight does not ship a fixed emergency corpus. [`knowledge/README.md`](knowledge/README.md) documents the pack format; real knowledge can be distributed and updated independently from the runtime.

One pack:

```bash
python src/main.py \
  --knowledge packs/water-en.zip \
  "We have no running water after the outage. How can I make collected water safer to drink?"
```

`--knowledge` is repeatable. Packs remain independent while LastLight searches them as one local corpus:

```bash
python src/main.py \
  --knowledge packs/water-en.zip \
  --knowledge packs/first-aid-en.zip \
  --knowledge packs/blackout-en.zip \
  "Someone is bleeding heavily and the power is out. What guidance is available?"
```

A typical pack looks like:

```text
water-en.zip
├── lastlight-pack.json
├── en/
│   └── water/
│       ├── purification.md
│       └── storage.md
└── sources/
    └── references.json
```

Verify a downloaded pack before using it:

```bash
python src/main.py --knowledge pack.zip --validate-pack
python src/main.py --knowledge pack.zip --verify-provenance
```

See [Knowledge Packs](docs/knowledge_packs.md) and [Knowledge Pack Provenance](docs/pack_provenance.md).

## Language behavior

Explicit `--language es` / `--language en` always wins. Without it, LastLight adopts a monolingual corpus language automatically and conservatively routes clear ES/EN queries inside mixed corpora. Retrieved passages remain in the original pack language; LastLight does not silently translate them.

## Evaluation

`--eval` runs a small deterministic regression suite for retrieval and refusal behavior.

```bash
python src/main.py --knowledge examplepack/lastlight-example-en.zip --eval
```

The committed example ZIP also has integration coverage for pack validation, HIGH-confidence water and bleeding retrieval, and an out-of-domain refusal case.

## Useful commands

| Task | Command |
| --- | --- |
| Try the bundled demo | `python src/main.py --knowledge examplepack/lastlight-example-en.zip "The water supply is down and I have no bottled water. I found water that looks clear. What should I do before drinking it?"` |
| One external pack | `python src/main.py --knowledge water.zip "What should I do if the water supply is unsafe?"` |
| Multiple packs | `python src/main.py --knowledge water.zip --knowledge first-aid.zip "What guidance do I have for safe water and a serious wound?"` |
| Fixed lexical | `python src/main.py --knowledge water.zip --strategy lexical "How can I make collected water safer?"` |
| Fixed BM25 | `python src/main.py --knowledge water.zip --strategy bm25 "How can I make collected water safer?"` |
| Adaptive balanced | `python src/main.py --knowledge water.zip --strategy adaptive --mode balanced "How can I make collected water safer?"` |
| Inspect adaptive plan | `python src/main.py --knowledge water.zip --strategy adaptive --mode balanced --plan "How can I make collected water safer?"` |
| JSON output | `python src/main.py --knowledge water.zip --format json "How can I make this water safer to drink?"` |
| Source ranking | `python src/main.py --knowledge water.zip --format sources "How can I make this water safer to drink?"` |
| Force Spanish | `python src/main.py --knowledge water.zip --language es "necesito ayuda"` |
| Validate pack | `python src/main.py --knowledge pack.zip --validate-pack` |
| Verify provenance | `python src/main.py --knowledge pack.zip --verify-provenance` |
| Run tests | `python -m unittest discover -s tests` |

## Research direction

LastLight treats offline intelligence as a systems problem rather than a model-size competition: how much useful, trustworthy assistance can be preserved per unit of compute, memory, energy and stored knowledge when external infrastructure is unavailable?

The project is intended to make that tradeoff measurable and auditable rather than hiding it behind a remote service.

## Docs

- [Architecture](docs/architecture.md)
- [Python API](docs/python_api.md)
- [Knowledge Packs](docs/knowledge_packs.md)
- [Knowledge Pack Provenance](docs/pack_provenance.md)
- [Adaptive Retrieval](docs/adaptive_retrieval.md)
- [Ecosystem](ECOSYSTEM.md)

## License

Mozilla Public License 2.0.
