iatoolkit 2.65.2__tar.gz → 2.66.0__tar.gz

{iatoolkit-2.65.2/src/iatoolkit.egg-info → iatoolkit-2.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.65.2
+Version: 2.66.0
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

{iatoolkit-2.65.2 → iatoolkit-2.66.0}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "2.65.2"
+__version__ = "2.66.0"
 
 # Expose main classes and functions at the top level of the package
 

{iatoolkit-2.65.2 → iatoolkit-2.66.0}/src/iatoolkit/config/system_agents/memory_compiler.prompt

@@ -10,7 +10,7 @@ How to write the page:
 
 - Follow the WIKI_SCHEMA.
 - When you update, return the COMPLETE new page: keep everything already on it, word for word, including other people's attributions, headings and order. Change only what the capture changes, and put new facts in the section where they belong.
-- When the capture contradicts the page, keep both statements with their attributions and make the conflict explicit; never delete what someone else said.
+- When the capture contradicts the page, keep both statements with their attributions and make the conflict explicit; never delete what someone else said. Also list each contradiction in `conflicts`.
 - Attribute every fact you add as ({{ author }}, {{ captured_on }}).
 - Write in the language of the page, or of the capture for a new page. Neutral tone, no personal opinions.
 - If attachments come with the capture, use what they say as part of the capture.
@@ -23,6 +23,7 @@ Answer with JSON following the schema:
 - `summary`: one sentence saying what the page covers.
 - `markdown`: the page body without frontmatter, starting with `# Title`.
 - `change_summary`: one short sentence for the page history (when you skip, why).
+- `conflicts`: each place where the capture contradicts what the page already said, with `existing_statement` (what the page said, as written), `existing_source` (its attribution), `new_statement` and `new_source` ({{ author }}, {{ captured_on }}). An empty list when nothing contradicts.
 
 WIKI_SCHEMA:
 {{ wiki_schema }}

iatoolkit-2.66.0/src/iatoolkit/config/system_agents/memory_document_ingest.prompt

@@ -0,0 +1,35 @@
+You maintain the company's Memory: a wiki of how things are actually done in this company (procedures, rules, exceptions, who decides). It is written from what its people explain and from the company's own documents.
+
+A document was loaded into Memory (SOURCE). You receive it in parts; this is part {{ part.index }} of {{ part.total }} (PART). Bring into the wiki what this part teaches about how things are done here.
+
+What to take:
+
+- Facts, rules, procedures, responsibilities, exceptions, deadlines, amounts and definitions that someone in the company would need to know or do their work.
+- Not the document's structure, legal boilerplate, signatures, indexes or anything that only restates the title.
+- Do not summarize the document: the document itself stays searchable. Write the knowledge where it belongs.
+
+How to write the pages:
+
+- Update one of the CANDIDATE_PAGES when the part belongs to its subject; create a new page when none covers it (check PAGE_INDEX first so you do not duplicate a page). One part may touch several pages; return each one.
+- When you update, return the COMPLETE new page: keep everything already on it, word for word, including people's attributions. Add the new facts in the section where they belong.
+- When this part says something different from what the page already says, keep both statements with their attributions and make the difference explicit; never delete what someone else said. Also list each contradiction in `conflicts`.
+- Attribute every fact you add as ({{ source.label }}, {{ captured_on }}).
+- Follow the WIKI_SCHEMA. Write in the language of the page, or of the document for a new page.
+- If this part has nothing worth keeping, return an empty `pages` list.
+
+Answer with JSON following the schema: a list `pages`, each with `action` (create or update), `target_page_id` (the page_id you update, or null), `title`, `summary` (one sentence on what the page covers), `markdown` (the page body without frontmatter, starting with `# Title`) and `change_summary` (one short sentence for the page history); and a list `conflicts`, one per contradiction with what a page already said: `page_title`, `existing_statement` (what the page said, as written), `existing_source` (its attribution), `new_statement` and `new_source` ({{ source.label }}, {{ captured_on }}). An empty list when nothing contradicts.
+
+SOURCE:
+{{ source | json }}
+
+PART {{ part.index }} OF {{ part.total }}:
+{{ part.text }}
+
+WIKI_SCHEMA:
+{{ wiki_schema }}
+
+PAGE_INDEX:
+{{ page_index | json }}
+
+CANDIDATE_PAGES:
+{{ candidate_pages | json }}

iatoolkit-2.66.0/src/iatoolkit/config/system_agents/memory_image_ingest.prompt

@@ -0,0 +1,25 @@
+You maintain the company's Memory: a wiki of how things are actually done in this company (procedures, rules, exceptions, who decides). It is written from what its people explain and from the company's own documents and images.
+
+An image was loaded into Memory (SOURCE); it comes attached. Look at it and bring into the wiki what it teaches about how things are done here: the steps of a diagram, the decisions of a whiteboard, the fields and rules of a form, the values of a screenshot.
+
+- Take facts, rules, procedures, responsibilities, amounts and definitions someone in the company would need. Describe what the image says, not what it looks like.
+- If the image has nothing worth keeping (a logo, a photo of people, decoration), return an empty `pages` list.
+- Update one of the CANDIDATE_PAGES when the image belongs to its subject; create a new page when none covers it (check PAGE_INDEX first so you do not duplicate a page).
+- When you update, return the COMPLETE new page: keep everything already on it, word for word, including people's attributions.
+- When the image says something different from what a page already says, keep both statements with their attributions and list each contradiction in `conflicts`.
+- Attribute every fact you add as ({{ source.label }}, {{ captured_on }}).
+- Follow the WIKI_SCHEMA. Write in the language of the page, or of the text in the image for a new page.
+
+Answer with JSON following the schema: a list `pages`, each with `action` (create or update), `target_page_id` (the page_id you update, or null), `title`, `summary`, `markdown` (the page body without frontmatter, starting with `# Title`) and `change_summary`; and a list `conflicts` (`page_title`, `existing_statement`, `existing_source`, `new_statement`, `new_source`), empty when nothing contradicts.
+
+SOURCE:
+{{ source | json }}
+
+WIKI_SCHEMA:
+{{ wiki_schema }}
+
+PAGE_INDEX:
+{{ page_index | json }}
+
+CANDIDATE_PAGES:
+{{ candidate_pages | json }}

iatoolkit-2.66.0/src/iatoolkit/config/system_agents_pack.yaml

@@ -0,0 +1,255 @@
+# System agents: model calls the platform makes on its own (see
+# services/system_agent_catalog.py). The tenant may pick each one's model
+# (system_agents.<key>.model in company.yaml); the prompt, inputs and output
+# schema belong to the code that reads the answer and are not editable.
+#
+# `prompt` is a Jinja template in system_agents/, rendered with `inputs`.
+# `default_model: null` means the company's default model.
+version: 1
+
+schemas:
+  # A Memoria page created, updated or left alone.
+  memory_page:
+    type: object
+    properties:
+      action:
+        type: string
+        enum: [create, update, skip]
+      # Nullable as a type list: the structured-output validator rejects null under anyOf.
+      target_page_id:
+        type: [integer, "null"]
+      title:
+        type: string
+      summary:
+        type: string
+      markdown:
+        type: string
+      change_summary:
+        type: string
+    # Only what a page cannot do without: models often drop the optional
+    # fields, and a near miss is repaired by the compiler's normalizer.
+    required: [action, target_page_id, title, markdown]
+    additionalProperties: false
+
+  # A memory_page plus the contradictions found while writing it (BL-014).
+  memory_page_with_conflicts:
+    type: object
+    properties:
+      action:
+        type: string
+        enum: [create, update, skip]
+      target_page_id:
+        type: [integer, "null"]
+      title:
+        type: string
+      summary:
+        type: string
+      markdown:
+        type: string
+      change_summary:
+        type: string
+      conflicts:
+        type: array
+        items:
+          type: object
+          properties:
+            existing_statement:
+              type: string
+            existing_source:
+              type: string
+            new_statement:
+              type: string
+            new_source:
+              type: string
+          required: [existing_statement, new_statement]
+          additionalProperties: false
+    required: [action, target_page_id, title, markdown]
+    additionalProperties: false
+
+agents:
+  - key: memory_compiler
+    name: Compilador de Memoria
+    name_en: Memory compiler
+    description: >-
+      (Memoria de la empresa) Integra lo que la gente guarda en Memoria en la página que corresponde,
+      o crea una nueva, atribuyendo cada dato a su autor.
+    description_en: >-
+      (Company memory) Files what people save in Memory into the right page, or creates a new
+      one, attributing every fact to its author.
+    module: memory
+    prompt: memory_compiler.prompt
+    output_schema: memory_page_with_conflicts
+    inputs: [author, captured_on, wiki_schema, page_index, capture, candidate_pages]
+    default_model: null
+
+  - key: memory_correction
+    name: Corrector de Memoria
+    name_en: Memory corrector
+    description: >-
+      (Memoria de la empresa) Aplica a una página de Memoria el cambio que alguien pidió, sin tocar el
+      resto de la página.
+    description_en: >-
+      (Company memory) Applies to a Memory page the change someone asked for, leaving the rest
+      of the page as it is.
+    module: memory
+    prompt: memory_correction.prompt
+    output_schema: memory_page
+    inputs: [author, captured_on, request, page]
+    default_model: null
+
+  - key: memory_question_review
+    name: Revisión de preguntas sin respuesta
+    name_en: Unanswered questions review
+    description: >-
+      (Memoria de la empresa) Revisa las conversaciones que buscaron en Memoria o en los documentos y
+      detecta las preguntas que la IA no pudo responder.
+    description_en: >-
+      (Company memory) Reviews the conversations that searched Memory or the documents and finds
+      the questions the AI could not answer.
+    module: memory
+    prompt: memory_question_review.prompt
+    output_schema:
+      type: object
+      properties:
+        items:
+          type: array
+          items:
+            type: object
+            properties:
+              ref:
+                type: string
+              answered:
+                type: boolean
+              question:
+                type: string
+              topic:
+                type: string
+              # Nullable as a type list: core's validator rejects null under anyOf.
+              same_as_question_id:
+                type: [integer, "null"]
+              same_as_ref:
+                type: [string, "null"]
+            required: [ref, answered]
+            additionalProperties: false
+      required: [items]
+      additionalProperties: false
+    inputs: [open_questions, turns]
+    default_model: null
+
+  - key: memory_document_ingest
+    name: Lector de documentos de Memoria
+    name_en: Memory document reader
+    description: >-
+      (Memoria de la empresa) Lee los documentos que se cargan en Memoria, tramo
+      por tramo, y lleva a las páginas de la wiki lo que enseñan sobre cómo se hacen
+      las cosas, citando el documento.
+    description_en: >-
+      (Company memory) Reads the documents loaded into Memory, part by part, and
+      files into the wiki pages what they teach about how things are done, citing
+      the document.
+    module: memory
+    prompt: memory_document_ingest.prompt
+    output_schema:
+      type: object
+      properties:
+        pages:
+          type: array
+          items:
+            type: object
+            properties:
+              action:
+                type: string
+                enum: [create, update]
+              # Nullable as a type list: the structured-output validator rejects null under anyOf.
+              target_page_id:
+                type: [integer, "null"]
+              title:
+                type: string
+              summary:
+                type: string
+              markdown:
+                type: string
+              change_summary:
+                type: string
+            required: [action, target_page_id, title, markdown]
+            additionalProperties: false
+        conflicts:
+          type: array
+          items:
+            type: object
+            properties:
+              page_title:
+                type: string
+              existing_statement:
+                type: string
+              existing_source:
+                type: string
+              new_statement:
+                type: string
+              new_source:
+                type: string
+            required: [page_title, existing_statement, new_statement]
+            additionalProperties: false
+      required: [pages]
+      additionalProperties: false
+    inputs: [source, part, captured_on, wiki_schema, page_index, candidate_pages]
+    default_model: null
+
+  - key: memory_image_ingest
+    name: Lector de imágenes de Memoria
+    name_en: Memory image reader
+    description: >-
+      (Memoria de la empresa) Mira las imágenes que se cargan en Memoria
+      (diagramas, fotos de pizarras, capturas de pantalla, formularios) y lleva a la
+      wiki lo que enseñan sobre cómo se hacen las cosas, citando la imagen.
+    description_en: >-
+      (Company memory) Looks at the images loaded into Memory (diagrams, whiteboard
+      photos, screenshots, forms) and files into the wiki what they teach about how
+      things are done, citing the image.
+    module: memory
+    prompt: memory_image_ingest.prompt
+    requires_vision: true
+    output_schema:
+      type: object
+      properties:
+        pages:
+          type: array
+          items:
+            type: object
+            properties:
+              action:
+                type: string
+                enum: [create, update]
+              target_page_id:
+                type: [integer, "null"]
+              title:
+                type: string
+              summary:
+                type: string
+              markdown:
+                type: string
+              change_summary:
+                type: string
+            required: [action, target_page_id, title, markdown]
+            additionalProperties: false
+        conflicts:
+          type: array
+          items:
+            type: object
+            properties:
+              page_title:
+                type: string
+              existing_statement:
+                type: string
+              existing_source:
+                type: string
+              new_statement:
+                type: string
+              new_source:
+                type: string
+            required: [page_title, existing_statement, new_statement]
+            additionalProperties: false
+      required: [pages]
+      additionalProperties: false
+    inputs: [source, captured_on, wiki_schema, page_index, candidate_pages]
+    default_model: null

{iatoolkit-2.65.2 → iatoolkit-2.66.0}/src/iatoolkit/repositories/memory_repo.py

@@ -9,7 +9,9 @@ from iatoolkit.repositories.database_manager import DatabaseManager
 from iatoolkit.repositories.models import (
     MemoryCapture,
     MemoryCaptureStatus,
+    MemoryConflict,
     MemoryItem,
+    MemoryPageDocument,
     MemoryWikiPageSource,
 )
 
@@ -167,6 +169,93 @@ class MemoryRepo:
         )
         return [page_id for (page_id,) in rows]
 
+    def add_page_document(self, company_id: int, wiki_page_id: int, document_id: int, label: str | None) -> None:
+        """Records that a page took facts from a RAG document (BL-014); keeps one link per pair."""
+        if not company_id or not wiki_page_id or not document_id:
+            return
+        link = (
+            self.session.query(MemoryPageDocument)
+            .filter_by(wiki_page_id=wiki_page_id, document_id=document_id)
+            .first()
+        )
+        if link is None:
+            self.session.add(MemoryPageDocument(
+                company_id=company_id,
+                wiki_page_id=wiki_page_id,
+                document_id=document_id,
+                label=(label or "")[:300] or None,
+            ))
+        elif label and link.label != label:
+            link.label = label[:300]
+        self.session.commit()
+
+    def list_page_ids_for_document(self, company_id: int, document_id: int) -> list[int]:
+        if not company_id or not document_id:
+            return []
+        rows = (
+            self.session.query(MemoryPageDocument.wiki_page_id)
+            .filter_by(company_id=company_id, document_id=document_id)
+            .order_by(MemoryPageDocument.id.asc())
+            .all()
+        )
+        return [page_id for (page_id,) in rows]
+
+    def list_page_documents(self, wiki_page_id: int) -> list[MemoryPageDocument]:
+        if not wiki_page_id:
+            return []
+        return (
+            self.session.query(MemoryPageDocument)
+            .filter_by(wiki_page_id=wiki_page_id)
+            .order_by(MemoryPageDocument.id.asc())
+            .all()
+        )
+
+    def list_document_links(self, company_id: int, document_id: int) -> list[MemoryPageDocument]:
+        if not company_id or not document_id:
+            return []
+        return (
+            self.session.query(MemoryPageDocument)
+            .filter_by(company_id=company_id, document_id=document_id)
+            .order_by(MemoryPageDocument.id.asc())
+            .all()
+        )
+
+    def list_obsolete_page_documents(self, company_id: int, limit: int = 50) -> list[MemoryPageDocument]:
+        """Pages that cite a deleted document and nobody reviewed yet."""
+        if not company_id:
+            return []
+        return (
+            self.session.query(MemoryPageDocument)
+            .filter(MemoryPageDocument.company_id == company_id,
+                    MemoryPageDocument.removed_at.isnot(None),
+                    MemoryPageDocument.reviewed_at.is_(None))
+            .order_by(MemoryPageDocument.removed_at.desc())
+            .limit(limit)
+            .all()
+        )
+
+    def get_page_document(self, company_id: int, link_id: int) -> MemoryPageDocument | None:
+        return self.session.query(MemoryPageDocument).filter_by(company_id=company_id, id=link_id).first()
+
+    def add_conflict(self, conflict: MemoryConflict) -> MemoryConflict:
+        self.session.add(conflict)
+        self.session.commit()
+        return conflict
+
+    def list_open_conflicts(self, company_id: int, limit: int = 50) -> list[MemoryConflict]:
+        if not company_id:
+            return []
+        return (
+            self.session.query(MemoryConflict)
+            .filter_by(company_id=company_id, status=MemoryConflict.STATUS_OPEN)
+            .order_by(MemoryConflict.created_at.desc())
+            .limit(limit)
+            .all()
+        )
+
+    def get_conflict(self, company_id: int, conflict_id: int) -> MemoryConflict | None:
+        return self.session.query(MemoryConflict).filter_by(company_id=company_id, id=conflict_id).first()
+
     def delete_page_sources_for_item(self, item_id: int) -> None:
         """Unlinks an item from every page. The pages themselves are never touched."""
         if not item_id:

{iatoolkit-2.65.2 → iatoolkit-2.66.0}/src/iatoolkit/repositories/models.py

@@ -564,6 +564,71 @@ class MemoryWikiPageSource(Base):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
 
 
+class MemoryPageDocument(Base):
+    """
+    A page of the company's Memoria wiki that took facts from a document of the
+    RAG (BL-014): which page cites which document, under what label.
+
+    `document_id` has no foreign key on purpose: when the document is deleted the
+    link stays, so the pages that cited it can be found and their facts marked
+    as obsolete.
+    """
+    __tablename__ = "iat_memory_page_documents"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    company_id = Column(Integer, ForeignKey(f"{ORM_SCHEMA}.iat_companies.id", ondelete="CASCADE"), nullable=False)
+    wiki_page_id = Column(Integer, ForeignKey(f"{ORM_SCHEMA}.iat_knowledge_wiki_pages.id", ondelete="CASCADE"),
+                          nullable=False, index=True)
+    document_id = Column(Integer, nullable=False, index=True)
+    label = Column(String, nullable=True)
+    # The document was deleted: its facts on the page are marked as obsolete and
+    # the page waits for someone to review it ("Necesita atención").
+    removed_at = Column(DateTime, nullable=True)
+    reviewed_at = Column(DateTime, nullable=True)
+    reviewed_by = Column(String, nullable=True)
+    created_at = Column(DateTime, default=datetime.now, nullable=False)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False)
+
+    __table_args__ = (
+        UniqueConstraint("wiki_page_id", "document_id", name="uix_memory_page_document_unique"),
+    )
+
+    def to_dict(self):
+        return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
+
+
+class MemoryConflict(Base):
+    """
+    Two sources that disagree on a page of the company's Memoria wiki (BL-014):
+    what the page already said and what a new capture or document says. The
+    page keeps both, attributed; the conflict waits in "Necesita atención" until
+    someone keeps one of them, or both.
+    """
+    __tablename__ = "iat_memory_conflicts"
+
+    STATUS_OPEN = "open"
+    STATUS_RESOLVED = "resolved"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    company_id = Column(Integer, ForeignKey(f"{ORM_SCHEMA}.iat_companies.id", ondelete="CASCADE"), nullable=False,
+                        index=True)
+    wiki_page_id = Column(Integer, ForeignKey(f"{ORM_SCHEMA}.iat_knowledge_wiki_pages.id", ondelete="CASCADE"),
+                          nullable=False, index=True)
+    capture_id = Column(Integer, nullable=True)
+    existing_statement = Column(Text, nullable=False)
+    existing_source = Column(String, nullable=True)
+    new_statement = Column(Text, nullable=False)
+    new_source = Column(String, nullable=True)
+    status = Column(String(16), nullable=False, default=STATUS_OPEN, index=True)
+    resolution = Column(String(32), nullable=True)
+    resolved_by = Column(String, nullable=True)
+    resolved_at = Column(DateTime, nullable=True)
+    created_at = Column(DateTime, default=datetime.now, nullable=False)
+
+    def to_dict(self):
+        return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
+
+
 class MemoryQuestion(Base):
     """
     A question about the company that the AI could not answer (BL-005, Fase 1).

{iatoolkit-2.65.2 → iatoolkit-2.66.0}/src/iatoolkit/services/configuration_service.py

@@ -543,6 +543,17 @@ class ConfigurationService:
                     elif agent_config.get("model") is not None and not isinstance(agent_config.get("model"), str):
                         add_error(f"system_agents.{agent_key}.model", "Must be a single model name.")
 
+        # Memoria's settings: which document types do not feed its wiki (BL-014).
+        memory_config = config.get("memory")
+        if memory_config is not None:
+            if not isinstance(memory_config, dict):
+                add_error("memory", "Must be a dictionary.")
+            else:
+                excluded = memory_config.get("excluded_document_types")
+                if excluded is not None and (
+                        not isinstance(excluded, list) or not all(isinstance(value, str) for value in excluded)):
+                    add_error("memory.excluded_document_types", "Must be a list of document types.")
+
         # 2. LLM section
         if not isinstance(config.get("llm"), dict):
             add_error("llm", "Missing or invalid 'llm' section.")